text:
#### Page Command

With the console started, the next step is to begin automation.
The `page` command prints a list of elements that are of interest.

```
[1] pry(main)> page
post /execute
{
    :script => "UIATarget.localTarget().frontMostApp().windows()[0].getTree()"
}
post /execute
{
    :script => "UIATarget.localTarget().frontMostApp().windows()[1].getTree()"
}
post /execute
{
    :script => "mobile: getStrings"
}
UIANavigationBar
   name: UICatalog
UIAStaticText
   name, label, value: UICatalog
UIATableView
   name, label: Empty list
   value: rows 1 to 10 of 12
UIATableCell
   name: Buttons, Various uses of UIButton
UIAStaticText
   name, label: Buttons, Various uses of UIButton
UIATableCell
   name: Controls, Various uses of UIControl
UIAStaticText
   name, label: Controls, Various uses of UIControl
UIATableCell
   name: TextFields, Uses of UITextField
UIAStaticText
   name, label: TextFields, Uses of UITextField
UIATableCell
   name: SearchBar, Use of UISearchBar
UIAStaticText
   name, label: SearchBar, Use of UISearchBar
UIATableCell
   name: TextView, Use of UITextField
UIAStaticText
   name, label: TextView, Use of UITextField
UIATableCell
   name: Pickers, Uses of UIDatePicker, UIPickerView
UIAStaticText
   name, label: Pickers, Uses of UIDatePicker, UIPickerView
UIATableCell
   name: Images, Use of UIImageView
UIAStaticText
   name, label: Images, Use of UIImageView
UIATableCell
   name: Web, Use of UIWebView
UIAStaticText
   name, label: Web, Use of UIWebView
UIATableCell
   name: Segment, Various uses of UISegmentedControl
UIAStaticText
   name, label: Segment, Various uses of UISegmentedControl
UIATableCell
   name: Toolbar, Uses of UIToolbar
UIAStaticText
   name, label: Toolbar, Uses of UIToolbar
```

Let's review in detail what this output means.

`[1] pry(main)> page` The 1 tells us this is the first command we've entered
during this pry session. The terminal will show `[2] pry(main)> ` which means
it's ready for the second command. Pry is an open source
[runtime development console](http://pryrepl.org/) that's used by appium
ruby console.

The next set of information is the network traffic.

```
{
    :script => "UIATarget.localTarget().frontMostApp().windows()[0].getTree()"
}
post /execute
{
    :script => "UIATarget.localTarget().frontMostApp().windows()[1].getTree()"
}
post /execute
{
    :script => "mobile: getStrings"
}
```

In response to the page command, three network requests were sent. The
[selenium-webdriver gem](http://rubygems.org/gems/selenium-webdriver) is used
to generate these requests.

After that is the result of the page command.

```
UIAStaticText
   name, label, value: UICatalog
```

`UIAStaticText` is the [iOS specific name](https://developer.apple.com/library/ios/documentation/ToolsLanguages/Reference/UIAStaticTextClassReference/UIAStaticText/UIAStaticText.html)
for the element. Appium uses [mechanic.js](https://github.com/jaykz52/mechanic)
and a set of shortcut names is available.

iOS Name             | Shortcut
                  --:|:--
UIAActionSheet       | actionsheet
UIAActivityIndicator | activityIndicator
UIAAlert             | alert
UIAButton            | button
UIACollectionCell    | collectionCell
UIACollectionView    | collection
UIAEditingMenu       | editingMenu
UIAImage             | image
UIAKey               | key
UIAKeyboard          | keyboard
UIALink              | link
UIAMapView           | mapView
UIAPageIndicator     | pageIndicator
UIAPicker            | picker
UIAPickerWheel       | pickerwheel
UIAPopover           | popover
UIAProgressIndicator | progress
UIAScrollView        | scrollview
UIASearchBar         | searchbar
UIASecureTextField   | secure
UIASegmentedControl  | segmented
UIASlider            | slider
UIAStaticText        | text
UIAStatusBar         | statusbar
UIASwitch            | switch
UIATabBar            | tabbar
UIATableView         | tableview
UIATableCell         | cell, tableCell
UIATableGroup        | group
UIATextField         | textfield
UIATextView          | textview
UIAToolbar           | toolbar
UIAWebView           | webview
UIAWindow            | window
UIANavigationBar     | navigationBar

Under each element name is a list of properties.

```
UIAStaticText
   name, label, value: UICatalog
```

In this case we see that the name, label, and value are all equal to UICatalog.

```
> name('UICatalog')
#<Selenium::WebDriver::Element:0x..f8575cfe515fb47ea id="0">
```

The name command in the appium ruby gem will search for a partial match on
either the name or the label. Once we've found the element,
then we can access the value attribute.

To find by value, we'd use:

```
> s_text 'UICatalog'
#<Selenium::WebDriver::Element:0x5e4e2159acc099a id="3">
```

This finds a static text that contains UICatalog. If we're looking for an
exact match, then s_text_exact works.

```
> s_text_exact 'UICatalog'
#<Selenium::WebDriver::Element:0x5e4e2159acc099a id="3">
```

These helper methods [are documented on GitHub](https://github.com/appium/ruby_lib/tree/master/docs).

To view all possible elements, there's a `source` command. The `page_class`
command will give you an overview of what classes exist on the current page.

```
> page_class
13x UIAStaticText
12x UIATableCell
4x UIAElement
3x UIAWindow
2x UIAImage
1x UIATableView
1x UIANavigationBar
1x UIAStatusBar
```

The page command excels at identifying the elements you're most likely
interested in automating. I encourage you to read through the existing docs
and try the methods on different elements.


text:
Reverse and Add
---------------

**Problem 45**

> Continually add a number to its reverse to arrive at a palindrome.

Full problem statement is available [here][mirror].

[mirror]: https://github.com/rdtsc/codeeval-problem-statements/tree/master/moderate/045-reverse-and-add/
          "View Problem Statement Mirror"

license: MIT

repository: rdtsc/codeeval-solutions

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: rdtsc/codeeval-solutions


text:
# Acknowledgements

- SciPipe is very heavily dependent on the proven principles form [Flow-Based
  Programming (FBP)](http://www.jpaulmorrison.com/fbp), as invented by [John Paul Morrison](http://www.jpaulmorrison.com/fbp).
  From Flow-based programming, SciPipe uses the ideas of separate network
  (workflow dependency graph) definition, named in- and out-ports,
  sub-networks/sub-workflows and bounded buffers (already available in Go's
  channels) to make writing workflows as easy as possible.
- This library is has been much influenced/inspired also by the
  [GoFlow](https://github.com/trustmaster/goflow) library by [Vladimir Sibirov](https://github.com/trustmaster/goflow).
- Thanks to [Egon Elbre](http://twitter.com/egonelbre) for helpful input on the
  design of the internals of the pipeline, and processes, which greatly
  simplified the implementation.
- This work is financed by faculty grants and other financing for the [Pharmaceutical Bioinformatics group](http://pharmb.io) of [Dept. of
  Pharmaceutical Biosciences](http://www.farmbio.uu.se) at [Uppsala University](http://www.uu.se), and by [Swedish Research Council](http://vr.se)
  through the Swedish [National Bioinformatics Infrastructure Sweden](http://nbis.se).
- Supervisor for the project is [Ola Spjuth](http://www.farmbio.uu.se/research/researchgroups/pb/olaspjuth).

repository: scipipe/scipipe

gha_language: Go

gha_license_id: MIT

repo_name: scipipe/scipipe


text:
# Breakpoint-pairs
Minor research internship of Sarah Mehrem.

The task of this project was to optimise DeepSV in regards to hyperparameters to increase its performance, and afterwards to explore its theoretical capabilities as an SV caller.
For that I used existing calls of GRIDSS, Manta, Lumpy and Delly. I trained and tested the DeepSV CNN on these variants (per caller) and investigated aspects such as perfromance with different
negative sets, channel importance and also compared it to the perfromance of the traditional SV callers using the gold-standard callset from svclassify:

ftp://ftp-trace.ncbi.nlm.nih.gov/giab/ftp/technical/svclassify_Manuscript/Supplementary_Information/Personalis_1000_Genomes_deduplicated_deletions.bed

# Gerenal workflow
I started off by creating the test and training data per caller. For that I generated genomewide channel data of the NA12878 once. The negative set genomic coordinates were generated using:
**MakeNegative_NoBP_NoBP.py
MakeNegative_CR_CR.py
MakeNegative_CR_TrueSV.py
MakeNegative_TrueSV_TrueSV.py**

We used window pairs (breakpoint-breakpoint) of channel windows as input. These were created using the scripts:
**MakeWindowPairs_genomewide.sh**
**MakeWindowPairs_genomewide_negative.sh**
and the VCF files of the respective callers and the genomic coordinates of the negative sets.

Final training and test sets were created using
**MakeTrainingData.py**

Next, to train the DeepSV CNN this script is used:
**OC_cross_validation_dropout.py**

In case of calculating channel importance, the above mentioned script was modified into:
**OC_cross_validation_dropout_zeroed.py**

In order to compare the performance of DeepSV to the other callers, these R scripts were used:
**BenchmarkCallerCNNsSummarisedNegSets.R**	 for a mean performance across negative sets
**BenchmarkGridssCNN.R** for each negative set individually
**OverlapOver10Runs.R** for overlap with the Mills and svclassify reference sets


text:
# Installation
```
nimble install https://github.com/tim-st/nim-lzma
```

# Usage

You will need the `liblzma` library installed on your system. If you're on Windows, download the file `liblzma.dll` from [here](https://tukaani.org/xz/).

```nim
import lzma

var s = "uncompressed data"
doAssert s.compress.decompress == s
```

repository: hagna/nim-lzma

repo_name: hagna/nim-lzma


text:
---
title: "Searching for answers using Google and StackOverflow"
---

Learning to program can be difficult and annoying. This guide aims at helping you to help yourself. First of all, learning to program does not mean that you should remember all features of a language, but rather that you are able to quickly solve the problems you come across.

The far most important skill for an efficient programmer is to be good at googling because google answers _all_ your questions.

### An example

Let us consider an example. Say, that I create the following string and store it in a variable.

  ```python
  # Creating a string, and stores is as `s`
  s = "thisisastring"

  # Let's try to replace `t` at index 0 with `k` and see what happens
  s[0] = "k"
  ```

This results in the following:

  ```python
  >>> # Creating a string, and stores is as `s`
  ... s = "thisisastring"
  >>>
  >>> # Let's try to replace `t` at index 0 with `k` and see what happens
  ... s[0] = "k"
  Traceback (most recent call last):
    File "<stdin>", line 2, in <module>
  TypeError: 'str' object does not support item assignment
  ```

Python tells us that we made a `TypeError`, and that `str` objects doesn't support item assignment. At first, these seems not very helpful because without prior programming experience this does not make sense. But let us try to see what happens if copy the line, and see what google suggest us.

As we see the first example seems rather advanced, so we continue to the second suggestion. Here we see that _Python_ doesn't allow us to change already created strings, but we are able to create a new string from slices of strings. Thus, this would result in what we tried to achieve.

  ```python
  # Assign `thisisastring` to the variable `s`
  s = "thisisastring"

  # Concatenate "k" with all characters from the string s from index 1
  # and until the end of the string to the variable `s2`
  s2 = "k" + s[1:]
  s2
  ```

Executing the code yields:

  ```python
  >>> s = "thisisastring"
  >>>
  >>> # Concatenate "k" with all characters from the string s from index 1
  >>> # and until the end of the string to the variable `s2`
  ... s2 = "k" + s[1:]
  >>> s2
  'khisisastring'
  ```

### Conclusion

The best way to seek answers to your questions is to google the error codes. The forum [StackOverflow](https://stackOverflow.com) was created to answer questions related to programming.

The second point to emphasize is that search engines tends to remove all special characters. This means that if you search for some code most of the code will be deleted. Therefore it is important to either search for the error code or words that identifies the problem.

Finally, google tends to be better at finding the right StackOverflow issue than StackOverflows search engine, so you would probably rather google your issues than searching for the answer on StackOverflow.

**Still not finding an answer?** Ask your question in the course forum using GitHub issues, [see this guide](/guides/github-issues).

**Asking questions on StackOverflow:** You can ask your questions on StackOverflow and someone will most probably answer them, but please make sure that you have ensured that the question has not been asked before. Some programmers tends to be rather angry if someone asks a question that has been answered earlier on.

gha_language: JavaScript


text:
## Overview
![Image](/public/Images/KOOMPI_menulist.png)
We are excited to announce, KOOMPI ISO version 2.5.4 has been released!
#### What's new?
- Theme Manager Applications and six themes of KOOMPI Themes (KOOMPI DARK, KOOMPI LIGHT, KOOMPI MOSX DARK, KOOMPI MOSX LIGHT, KOOMPI WINX DARK, KOOMPI WINX LIGHT)
- Touchpad supports up to four fingers-gestures, both swiping and pinching
- Teamviewer, Master PDF, Discover stores, Xtreme Download Manager, and Dolphine improvement
- Applications Menu list have been created (Click KOOMPI LOGO)
- Printer driver improvement (supports most of the  models)
- pix command input
- PulseAudio and pi command are improved
- Kernel has been updated to 5.6

#### Instruction
You can download the ISO from the link below, flash it to your USB (8BG minimum), boot into the live USB and run the system installation.

**Download:** **[https://repo.koompi.org/iso/KOOMPI-OS-2020.04.26-x86_64.iso](https://repo.koompi.org/iso/KOOMPI-OS-2020.04.26-x86_64.iso)**

branch_name: refs/heads/main

gha_language: HTML


text:
# Overview

The<EMAIL_ADDRESS>module contains a set of basic 3D framework classes intended
to facilitate application development.

## Remarks

- The engine classes are built on top of the abstract API in<EMAIL_ADDRESS>module
and are thus portable between GPUs.

gha_language: TypeScript

gha_license_id: NOASSERTION


text:
# le-creyol
Multi-Objective PSO used to cluster static data

## Clustering Static Data
For this assignment, you have to develop a multi-objective PSO to cluster data, assuming static data. The data clustering problem is a multi-objective problem, with the following two objectives:
* minimize intra-cluster distances, and
* maximize inter-cluster distances.

Think carefully about:
1. the representation (how a particle will represent the solution) and
2. the formulation of the objective functions.

Start by assuming that the number of clusters is a priori specified (i.e known). Then, think of an approach in which the PSO can also dynamically determine the optimal number of clusters.
Evaluate the performance of your multi-objective PSO dat aclustering algorithm using appropriate performance measures for multi-objective optimization problems. Make sure that you evaluate the performance over a number of data sets of varying complexity.

repository: kmdinake/le-creyol

repo_name: kmdinake/le-creyol


text:
# Activenavbar [![Gem Version](https://badge.fury.io/rb/activenavbar.svg)](http://badge.fury.io/rb/activenavbar) [![Gem Total Downloads](https://img.shields.io/gem/dt/activenavbar.svg)](https://rubygems.org/gems/activenavbar)

active navbar is used to set the active navbar link, a navbar link becomes active when you click on it.

## Installation

The simplest way to install is to use Bundler.

Add this line to your application's Gemfile:

```ruby
gem 'activenavbar', '~> 1.0.4'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install activenavbar

## Method

    navbar_link(label, path, active_class)

- label: the link label.
- path: the link path or controller path.
- active_class: the style sheet active class.

## Usage

Assume we have home, food and beverage page, and have navbar for each page below:

    %ul
      %li
        = link_to "Home", homes_path
      %li
        = link_to "Food", foods_path
      %li
        = link_to "Beverage", beverages_path

Assume we have style sheet for navbar below:

    ul {
      list-style-type: none;
      overflow: hidden;
    }

    li {
      float: left;
    }

    .nav > li > a {
      border-right: 1px solid #A80000;
      padding: 5px;
      color: #000;
    }

    .nav .active > a,
    .nav .active > a:focus {
      color: red;
    }

Now we want a navbar link becomes active when we click on it:

    %ul
      = navbar_link "Home", root_path, "active"
      = navbar_link ' Food', foods_path, "active"
      = navbar_link "Beverage", beverages_path, "active"

Well, Home link becomes active when we click on Home link.

HTML output:

Home

Food

Beverage

## License

[MIT License](https://github.com/Bunlong/activenavbar/blob/master/LICENSE)

Copyright (c) 2014 - Present, [Bunlong VAN](https://github.com/Bunlong) ( Maintainer )

repository: Bunlong/activenavbar

repo_name: Bunlong/activenavbar


text:
I can't wait to hack on it and do something cool!

## Two avenues
For one, since I am learning to program in Javascript, the obvious choice would be the [Espruino Pixl.js](https://shop.espruino.com/pixljs), which looks like a fun device.

It's an all in one Javascript microprocessor with a built in display.

![Espruino Pixl.js](./pixl.jpg "Espruino Pixl.js")

But I wanted a challenge, something that I could expand more at a later time. So I am opting for the [Raspberry Pi Zero W](https://www.raspberrypi.org/products/raspberry-pi-zero-w/). It comes with Wireless and Bluetooth built into a ~ $10 computer!

![Raspberry Pi Zero W](./rasp_pi.png "Raspberry Pi Zero W")

I plan on putting [Rasbian or Ubuntu Core](https://www.raspberrypi.org/downloads/) as the Operating System and then installing a NodeJS server for fun. Now I can run Javascript on a development server.

## Fun Stuff
I think it would be really fun to do something with a display, so I am looking at the [Inky pHAT](https://thepihut.com/products/inky-phat), an E-Ink colorful display I can hook right up to the Raspberry Pi Zero.

![Inky pHAT](./rasp_pi_inky.jpg "Inky pHAT")

Keep you posted on what I come up with!


text:
# Quick Copy chrome extension overview

Quickly copy configured text to clipboard with two clicks. Sync configured text across devices.

![Promo Tile](docs/publish/common/promo_tile.png)
#### [Chrome webstore link](https://chrome.google.com/webstore/detail/quick-copy/llemocbeniphffbfjifkpkdkheicomdf)

#### [Microsoft Edge Add-ons link](https://microsoftedge.microsoft.com/addons/detail/quick-copy/giodfegjpbcahiaegpmccclhgolnpldc)

# Configuring and running the project

## Installation
1. Install [Node.js](https://nodejs.org/en/download/)
2. Clone this repository
3. Run `npm install` from root directory of the project

## Running the extension on chrome (or edge) in developer mode
1. Build the project using following command from root directory
`npm run-script build-no-embed-script`
2. A `build` directory will be created at root of project.
3. Follow the instructions at this [link](https://webkul.com/blog/how-to-install-the-unpacked-extension-in-chrome/) and load the `build` directory as extension

## Running on web browser (not as extension)
If you need to test out just UI and not storage/retrieval of data then you can run this as SPA on browser and not as extension. This is very helpful since you don't need to build and load the extension in the browser everytime after small change.

To do this you need to:
1. Comment out the code related to storage & retrieval of data in `App.js` file. Comment out all the lines with `window.chrome.storage.sync`. I have comments in the `App.js` file to indicate this.
2. Uncomment below line in `App.js` to load the test data
    ```javascript
    //const[userList, setUserList] = useState(testData);
    ```
3. Run `npm start` from root directory and it will open up the browser window with test data.

# Contribution
Check out [Issues](https://github.com/somared/QuickCopyChromeExt/issues) on Github of this project and send pull request for bug fix or enhancement.

repository: somared/QuickCopyChromeExt

repo_name: somared/QuickCopyChromeExt


text:
### 2018-10-07
diff between today and yesterday

#### python
* [TheSecondSun/Shellab](https://github.com/TheSecondSun/Shellab): Linux and Windows shellcode enrichment utility
* [scikit-learn/scikit-learn](https://github.com/scikit-learn/scikit-learn): scikit-learn: machine learning in Python
* [internetarchive/openlibrary](https://github.com/internetarchive/openlibrary): One webpage for every book ever published!
* [python/cpython](https://github.com/python/cpython): The Python programming language
* [shubhomoydas/ad_examples](https://github.com/shubhomoydas/ad_examples): A collection of popular anomaly detection methods (iid/point-based and time series) including active learning for anomaly detection/discovery, description for diversity/explanation/interpretability. With a deeper analysis of incorporating label feedback with ensemble and tree-based detectors. Includes results-plots and illustrations for most app

#### go
* [ethereum/go-ethereum](https://github.com/ethereum/go-ethereum): Official Go implementation of the Ethereum protocol
* [rogpeppe/gohack](https://github.com/rogpeppe/gohack): Make temporary edits to your Go module dependencies
* [mattermost/mattermost-server](https://github.com/mattermost/mattermost-server): Open source Slack-alternative in Golang and React - Mattermost
* [derekparker/delve](https://github.com/derekparker/delve): Delve is a debugger for the Go programming language.

#### cpp
* [emilengler/sysget](https://github.com/emilengler/sysget): One package manager to rule them all
* [oatpp/oatpp](https://github.com/oatpp/oatpp): Light, zero-dependency framework. Create bleedingly-fast web-services. Organic. Pure C++
* [protocolbuffers/protobuf](https://github.com/protocolbuffers/protobuf): Protocol Buffers - Google's data interchange format
* [Microsoft/LightGBM](https://github.com/Microsoft/LightGBM): A fast, distributed, high performance gradient boosting (GBDT, GBRT, GBM or MART) framework based on decision tree algorithms, used for ranking, classification and many other machine learning tasks. It is under the umbrella of the DMTK(http://github.com/microsoft/dmtk) project of Microsoft.
* [ocornut/imgui](https://github.com/ocornut/imgui): Dear ImGui: Bloat-free Immediate Mode Graphical User interface for C++ with minimal dependencies
* [gzc/CLRS](https://github.com/gzc/CLRS): Solutions to Introduction to Algorithms
* [EOSIO/eos](https://github.com/EOSIO/eos): An open source smart contract platform
* [Ewenwan/MVision](https://github.com/Ewenwan/MVision):   SLAM ORB LSD SVO DSO yolov3  opencv PCL
* [yuzu-emu/yuzu](https://github.com/yuzu-emu/yuzu): Nintendo Switch Emulator
* [google/googletest](https://github.com/google/googletest): Google Test

#### javascript
* [EyalPerry/dev-cv](https://github.com/EyalPerry/dev-cv): A CV Template for Software Developers
* [aholachek/react-flip-toolkit](https://github.com/aholachek/react-flip-toolkit): A React FLIP animation library for highly configurable transitions
* [zeit/next.js](https://github.com/zeit/next.js): The React Framework
* [mattdesl/canvas-sketch](https://github.com/mattdesl/canvas-sketch): [beta] A framework for making generative artwork in JavaScript and the browser.
* [Kickball/awesome-selfhosted](https://github.com/Kickball/awesome-selfhosted): This is a list of Free Software network services and web applications which can be hosted locally. Selfhosting is the process of locally hosting and managing applications instead of renting from SaaS providers.

#### coffeescript
* [atom/language-c](https://github.com/atom/language-c): C support in Atom
* [rubykube/peatio-trading-ui](https://github.com/rubykube/peatio-trading-ui): Peatio trading UI extracted as separate Rails 5 application.

gha_language: Python


text:
# Sofie: The Modern TV News Studio Automation System (tv-automation-server-core)

This is the core application of the [**Sofie** TV News Studio Automation System](https://github.com/nrkno/Sofie-TV-automation/).

## Local development
First, install Meteor:

* [Meteor Installation Guide](https://www.meteor.com/install)

Then, clone the repository and install all dependencies:
(Make sure your NODE_ENV is NOT set to production!)

```
git clone -b master https://github.com/nrkno/tv-automation-server-core.git
cd tv-automation-server-core/meteor
meteor npm install
meteor
```

If you run into any issues while installing the dependencies, clone any offending packages from Git and link them using `npm link`. For example, for `tv-automation-mos-connection` library:

```
git clone -b master https://github.com/nrkno/tv-automation-mos-connection.git
cd tv-automation-mos-connection
npm run build
npm link
cd ../tv-automation-server-core/meteor
npm link mos-connection
```

## System settings

In order for the system to work properly, it may be neccessary to set up several system properties. These can be set through environement variables - if not present, default values will be used.

|Setting         |Use                                                       |Default value      |
|----------------|----------------------------------------------------------|-------------------|
|`NTP_SERVERS`   |Comma separated list of time servers to sync the system to|`0.se.pool.ntp.org`|
|`FRAME_RATE`    |Framerate to be used when displaying time with frame accuracy|`25`            |

## Additional views

For the purpose of running the system in a studio environment, there are additional endpoints, unavailable from the menu structure.

|Path     |Function     |
|---------|-------------|
|`/countdowns/:studioId/presenter`|Countdown clocks for a given studio, to be shown to the studio presenter|
|`/activeRundown/:studioId`|Redirects to the rundown currently active in a given studio|
|`/prompter/:studioId`|A simple prompter for the studio presenter|

## Studio mode

In general, you will want to limit the amount of client stations that have full control of the studio (such as activating rundowns, taking parts, ad-libbing, etc.). In order to mark a given client station (browser) as a Studio Control station, you should append `?studio=1` to any query string, for example:

```http://localhost:3000/?studio=1```

This setting is persisted in browser's Local Storage. To disable studio mode in a given client, append `?studio=0`.

## Configuration mode

In the default mode, the Settings page will be unavailable from main navigation. If you want access to the Settings page on a given client station, append `?configure=1` to any query string.

```http://localhost:3000/?configure=1```

## Developer mode

In developer mode, right click is not disabled

```http://localhost:3000/?develop=1```

## Language selection

The UI will automatically detect user browser's default matching and select the best match, falling back to english. You can also force the UI language to any language by navigating to a page with `?lng=xx` query string, for example:

```http://localhost:3000/?lng=xx```

This choice is persisted in browser's Local Storage, and the same language will be used until a new forced language is chosen using this method.

## Operating the prompter screen

The prompter has several operating modes, described further below.
All modes are intended to be controlled by a computer mouse or similar, such as a presenter tool.
To cycle between operating modes, press *both mouse keys* simultaneously.

The prompter can be configured using URL parameters:

| Query parameter | Type    | Description                                                                                | Default  |
|-----------------|---------|-------------------------------------------------------------------------------------------------|----------|
| mirror          | string  | Mirror the display horisontally                                                                 |          |
| vmirror         | string  | Mirror the display vertically                                                                   |          |
| mode            | string  | Restrict the operating mode. Possible values: "normal", "speed", "smoothscroll"                 |          |
| followtake      | 0 / 1   | Whether the prompter should automatically scroll to current segment when the operator TAKE:s it | 1        |
| fontsize        | number  | Set a custom font size of the text. 20 will fit in 5 lines of text, 14 will fit 7 lines etc..   | 14       |
| marker          | string  | Set position of the read-marker. Possible values: "center", "top", "bottom", "hide"             | "hide"   |
| margin          | number  | Set margin of screen (used on monitors with overscan), in %.                                    | 0        |

Example: http://mySofie/prompter/studio0/?mode=smoothscroll&followTake=0&fontsize=20

### Normal Scrolling
Nothing fancy, use it like a normal web page

### Speed control
* Scrolling the mouse wheel sets the speed
* Click Left mouse button to toggle scrolling
* Hold Left mouse button to toggle scrolling
* Click Right mouse button to toggle rewind scrolling
* Hold Right mouse button to toggle rewind scrolling

### Smooth scrolling
* Scrolling the mouse wheel starts continous scrolling. Small speed adjustments can then be made by nudging the scroll wheel. Stop the scrolling by making a "larger scroll" on the wheel.

The prompter can be operated using pressing & holding keyboard arrow keys: `Up` & `Down`. Press `Home` to enable auto-scroll mode. `Shift+Up` and `Shift+Down` scrolls in 3x speed. If the studio setup requries a mirrored-image prompter, you can append `?mirror=1` to enable mirror mode. This setting is not persisted in browser.

## Translating Sofie

For support of various languages in the User Interface, Sofie uses the i18next framework. It uses JSON-based translation files to store UI strings. In order to build a new translation file, first extract a PO template file from Sofie UI source code:

```
cd meteor
npm run i18n-extract-pot
```

Find the created `template.pot` file in `meteor/i18n` folder. Create a new PO file based on that template using a PO editor of your choice. Save it in the `meteor/i18n` folder using your ISO 639-1 language code of choice as the filename.

Next, modify the `package.json` scripts and create a new language compilations script:

```
"i18n-compile-json": "npm run i18n-compile-json-nb & npm run i18n-compile-json-sv & npm run i18n-compile-json-xx",
"i18n-compile-json-xx": "i18next-conv -l nb -s i18n/xx.po -t public/locales/xx/translations.json",
```

Then, run the compilation script:

```npm run i18n-compile-json```

The resulting JSON file will be placed in `meteor/public/locales/xx`, where it will be available to the Sofie UI for use and autodetection.

---

*The NRK logo is a registered trademark of Norsk rikskringkasting AS. The license does not grant any right to use, in any way, any trademarks, service marks or logos of Norsk rikskringkasting AS.*

repository: ThinkAM/tv-automation-server-core

repo_name: ThinkAM/tv-automation-server-core


text:
* [Coding Style Guideline for C](#coding-style-guideline-for-c)
  * Validated Struct
  * Header Files
  * Formatting
  * Naming
  * Comments
* [Coding Style Guideline for Javascript](#coding-style-guideline-for-javascript)
  * Javascript Language Rules
  * Javascript Style Rules
    * Naming
    * Formatting
* [Coding Style Guideline for Python](#coding-style-guideline-for-python)

# Coding Style Guideline for C

Our coding style guideline is based on [google c++ coding standard](https://google.github.io/styleguide/cppguide.html),
but modified due to some difference between C and C++.
When this guideline is ambiguous, just follow the result of running `./tools/check_tidy.py`.

Here are `./tools/check_tidy.py` options:
```
--autoedit: Automatically edit the detected clang format errors. No diffs will be displayed.
```

## Validated Struct
Use [Validated Struct](../devs/Inside-IoT.js-Validated-Struct.md) whenever possible, for encapsulation and validity check.

## Header Files

### #define guard
Use #define guard in all header files. `<FILE>_H` format is recommended.

    #ifndef FILE_H
    #define FILE_H
        ...
    #endif // FILE_H

## Formatting

### Line length
maximum 80 characters in a line.

### Indentation
2 space indent at a time. Do not use a tab for indentation.

### Vertical whitespace
Add two blank lines between functions.

Otherwise minimize use of vertical whitespace.

This is more a principle than a rule: don't use blank lines when you don't have to. In particular, don't put more than two blank lines between functions, resist starting functions with a blank line, don't end functions with a blank line, and be discriminating with your use of blank lines inside functions.

### Function call
Write a function call all in a line if it fits. If not, break the line into multiple lines after assignment operator, or insert newline between parameters.
Do not insert spaces after open paren and before close paren.

    int value = foo(arg1, arg2, arg3);

    int value =
        foo(arg1, arg2, arg3);

    int value = foo(arg1, arg2,
                    arg3);

### Function Declaration and Definition
Use named parameters in function declaration.

    return_type function_name(int, char); // not allowed
    return_type function_name(int arg1, char arg2); // Use this

Return type should be on the same line as function name and parameters if it fits. If not, break between them aligned with the first argument.

    return_type function_name(int arg1,
                              char arg2);

If even first argument does not fit in a line, write it in a new line with 4 space indent.

    return_type function_name(
        int arg1, char arg2);

The open curly brace should be at the same line. The close curly brace should be either at the same line as its open curly brace or at new line.

    return_type function_name(int arg1, char arg2) { };
    return_type function_name(int arg1, char arg2) {
      ...
    }
    return_type function_name(int arg1, char arg2)
    {  // not allowed
      ...
    }

### Conditionals
Use a space between the if and open brace. Open brace on the same line as the if.

    if (condition) {
        ...
    }

Short conditional statements may be written without braces.

    if (condition)
      do_something();

### Loops and Switches
Use a space between the switch and loops(for, while, do-while) and open brace. Open brace on the same line as the switch and loops.

    while (condition) {
      ...
    }

Single loop body statement may be written without braces.

    while (condition)
      do_something(); // ok
    for (condition)
      do_something(); // ok

## Naming

### Type names
Use lower cases and underscore for struct names, and add prefix `iotjs_` and suffix `_t`.

    typedef struct {
      ...
    } iotjs_name_t;

### Function names
Use lower cases and underscore for function names.

For constructors, destructor, and methods of validated struct `iotjs_mystruct_t`, use names starting with `iotjs_mystruct_*`.
Constructor function name should be either `iotjs_mystruct_create` or `iotjs_mystruct_initialize`,
depending on whether the constructor returns the instance as return value, or the constructor just initializes the instance passed by parameter.

```c
typedef struct {
} IOTJS_VALIDATED_STRUCT(iotjs_mystruct_t);

iotjs_mystruct_t iotjs_mystruct_create(); // Ok
iotjs_mystruct_t* iotjs_mystruct_create(); // Ok
void iotjs_mystruct_initialize(iotjs_mystruct_t*); // Ok

void iotjs_mystruct_destroy();

int iotjs_mystruct_method();
```

### Variable names
Use lower cases and underscore for variable names.

    int lower_case_variable;

## Comments

### Comment style
Use either // or /* */ style comments. However, // style is much prefered.

# Coding Style Guideline for Javascript

This coding standard is based on [google javascript coding standard](https://google.github.io/styleguide/javascriptguide.xml)

## Javascript Language Rules

### var
Always declare variable before use.

### Semicolons
Always use semicolons.

### Function Declaration in blocks
Do not declare functions within a block.

### Wrapper objects of primitive types
Do not use wrapper objects for primitive types.

### with
Do not use `with` statement.

### Modifying prototypes of builtin objects
Do not modify prototypes of builtin objects

## Javascript Style Rules

### Naming
Use lowerCamelCase for variable names and function names.

    var myFirstVariable;
    function myFirstFunction {
      ...
    }

Use UpperCamelCase for constructor names

    function MyConstructorFunction(input) {
      this.variable = input;
      ...
    }

### Formatting
Follow C/C++ formatting above.

# Coding Style Guideline For Python

The coding conventions for Python code follows [PEP 8 - Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)

repository: Samsung/TizenRT

gha_language: C

repo_name: Samsung/TizenRT


text:
# [Toro Theme](http://jurs.me)

## Requirements

Toro requires a few thing to work:

- [Node.js](http://nodejs.org/)
- [Bower](http://bower.io/)
- [Grunt](http://gruntjs.com/)

## Installation

### Installing Node.js

Download the installer from [here](http://nodejs.org/download/) and you are ready to go.

### Installing Bower

Bower depends on [Node](http://nodejs.org/) and [npm](http://npmjs.org/). It's installed globally using npm:

```
npm install -g bower
```

Also make sure that git is installed as some bower packages require it to be fetched and installed.

### Installing Grunt

Installing the CLI

**If you're upgrading from Grunt 0.3, please see [Grunt 0.3 Notes](http://gruntjs.com/upgrading-from-0.3-to-0.4#grunt-0.3-notes)**

In order to get started, you'll want to install Grunt's command line interface (CLI) globally. You may need to use sudo (for OSX, *nix, BSD etc) or run your command shell as Administrator (for Windows) to do this.

```
npm install -g grunt-cli
```

This will put the ```grunt``` command in your system path, allowing it to be run from any directory.

Note that installing ```grunt-cli``` does not install the Grunt task runner! The job of the Grunt CLI is simple: run the version of Grunt which has been installed next to a ```Gruntfile```. This allows multiple versions of Grunt to be installed on the same machine simultaneously.

## Usage

Assuming that the stuff above has been installed you should be able to follow these steps to start working with Toro:

1. Fire up Terminal
2. Change to the project's root directory.
3. Install Toro dependancies with ```bower install```
3. Install grunt project dependencies with ```npm install```.
4. Copy and convert flexbox and owlcarousel styles with```grunt copy```
4. Run Grunt with ```grunt```.

That's really all there is to it. Grunt is now listening to changes in sass and javascript files and compiles, concatenates, minifies and outputs the necessary files.

Next time you return to the project you only need to run ```grunt``` (step 5) make grunt watch the project again.

## Adding packages with bower

Using a local or remote package

```
bower install <package>
```
Installing a local or remote package and add it into the project's bower.json dependencies

```
bower install <package> -save
```

Using a specific version of a package

```
bower install <package>#<version>
```

Using a different name and a specific version of a package

```
bower install <name>=<package>#<version>
```

Where ```<package>``` can be any one of the following:

- A name that maps to a package registered with Bower, e.g, ```jquery```. ‡
- A public remote Git endpoint, e.g., ```git://github.com/someone/some-package.git```. ‡
- A private Git repository, e.g., ```https://github.com/someone/some-package.git```. If the protocol is https, a prompt will ask for the credentials. ssh can also be used, e.g., ```git@github.com:someone/some-package.git``` and can authenticate with the user's ssh public/private keys. ‡
- A local endpoint, i.e., a folder that's a Git repository. ‡
- A public remote Subversion endpoint, e.g., ```svn+http://package.googlecode.com/svn/```. ‡
- A private Subversion repository, e.g., ```svn+ssh://package.googlecode.com/svn/```. ‡
- A local endpoint, i.e., a folder that's an Subversion repository, e.g., ```svn+file:///path/to/svn/```. ‡
- A shorthand endpoint, e.g., ```someone/some-package``` (defaults to GitHub). ‡
- A URL to a file, including ```zip``` and ```tar``` files. Its contents will be extracted.

‡ These types of ```<package>``` might have versions available. You can specify a [semver](http://semver.org/) compatible version to fetch a specific release, and lock the package to that version. You can also specify a [range](https://github.com/isaacs/node-semver#ranges) of versions.

If you are using a package that is a git endpoint, you may use any tag, commit SHA, or branch name as a version. For example: ```<package>#<sha>```. Using branches is not recommended because the HEAD does not reference a fixed commit SHA.

If you are using a package that is a subversion endpoint, you may use any tag, revision number, or branch name as a version. For example: ```<package>#<revision>```.

All package contents are installed in the ```bower_components``` directory by default. You should **never** directly modify the contents of this directory.

Using ```bower list``` will show all the packages that are installed locally.

## Troubleshooting Windows

There are a few additional steps when using grunt on Windows (Vista+).

1. You need to set up Ruby 1.9.3 and use this to install SASS. "Start Command Prompt with Ruby".
2. Set up the correct path and environment variables.
	1. From the Desktop, right-click `My Computer` and click `Properties`.
	2. Click `Advanced System Settings` link in the left column.
	3. In the System Properties window click the `Environment Variables` button.
	4. Under `System Variables` find the `path` variable and add (**Not replace!**) `C:\Program Files\nodejs\;C:\Program Files (x86)\Git\cmd;C:\Ruby193\bin` if it isn't allready there.

After this you should be able to run the grunt commands without problems.

repository: Jursdotme/toro

gha_language: CSS

repo_name: Jursdotme/toro


text:
# Universal Middleware Pipeline

VioletGrass.Middleware is a universal middleware pipeline intended to be added to custom adapter solutions (e.g. message queue client library to business logic function) or extension points within applications.

![build](https://github.com/violetgrass/middleware/workflows/Build-CI/badge.svg)
![license:MIT](https://img.shields.io/github/license/violetgrass/middleware?style=flat-square)
[![Nuget](https://img.shields.io/nuget/v/VioletGrass.Middleware?style=flat-square)](https://www.nuget.org/packages/VioletGrass.Middleware/)

## Features

- **Extensible Middleware Builder**: A middleware builder building a composite function based on a three staged phase (configuration, building, actual middleware). Extensible by extension methods with access to a IServiceBuilder.
- **Parameterizable Context Type**: The key capability not offered by the ASP.NET Core Abstractions. The core invocation context is a parameterizable type (e.g. `MessageQueueContext`, `ImageProcessorContext`, ...).
- **Middleware Branching**: A middleware can be branched and designed for different middleware routes. The route matching is based on predicates (and not URLs) and can be customized for specific need. A simple regular expression based `StringRouter` is included.
- **Endpoint Routing**: Endpoints can be defined with routing predicates and metadata attached to them, which is accessible througout the middleware stack.

## Examples

All example should work under namespace `using VioletGrass.Middleware` (after installing NuGet package `VioletGrass.Middleware`)

### Creation of a simple stack only middleware

Used as core foundation, can be utilized for extensions points (it is essentially just a function in the end) or as the base for an extensive dispatching infrastructure.

````csharp
var stack = new MiddlewareBuilder<Context>()
    .Use(async (context, next) => {
        Console.Write("Violet");
        await next(context);
    })
    .Use(async (context, next) => {
        Console.Write("Grass");
        await next(context);
    })
    .Build();

// a context can be also other types being derived from Context
var x = new Context();

// this is just a function
await stack(x); // writes "VioletGrass"
````

Public APIs: `IMiddlewareBuilder<TContext>`, `MiddlewareBuilder<TContext>`, `MiddlewareDelegate` (build result), `IMiddlewareBuilderExtensions` (`Use` with lambda), `Context` (base class).

### TContext Type Parameter

The purpose of this library is the flexible usage in different scenarios. ASP.NET Core's middleware stack is tightly coupled to the `HttpContext`. As a result it cannot be re-used. `IMiddlewareBuilder<TContext>` and the rest of the library is built with re-use for different context types in mind.

````csharp
public class QueueMessageContext : Context
{
    public Message Message { get; set; }
    ...
}

var stack = new MiddlewareBuilder<QueueMessageContext>()
    .Use(async (context, next) => {
        Console.Write(context.Message.Body);
        await next(context);
    })
    .Build();

var x = new QueueMessageContext(...);

await stack(x);
````

Public APIs: `Context` (base class), `TContext` (type parameters on most of library)

### Predicate based routing (usally behind the scenes)

Middleware can branch. The basic switching pattern is a predicate utilizing the context. Each branch creates a new middleware.

````csharp
var stack = new MiddlewareBuilder<Context>()
    .UseRoutes(
        new Route<Context>(context => context.Feature<string>() == "Hello", branchBuilder => branchBuilder
            .Use(async (context, next) => { Console.Write("Hello"); await next(context); })
            .Use(async (context, next) => { Console.Write("World"); await next(context); })
        ),
        new Route<Context>(context => true, branchBuilder => branchBuilder
            .Use(async (context, next) => { Console.Write("I am never called"); await next(context); })
        )
    )
    .Build();

// for the sake of simplicity, misusing string as a feature
await stack(new Context("Hello"));
````

Public APIs: `Route<TContext>`, `IMiddlewareBuilderExtensions` (UseRoutes)

### String Router

While the core engine does support routes, it does on programmatic predicates and not on a string matching. The `StringRouter` adds support for routing keys (e.g. from queing systems or the HTTP Uri based on regular expressions).

The method `UseRoutingKey` selects a string from the `TContext` to be (optionally) dissected in multiple

````csharp
var stack = new MiddlewareBuilder<Context>()
    .UseRoutingKey(c => c.Feature<Message>().RoutingKey, // select a routing key from the context (e.g. a MQ routing key or the HTTP Uri)
        "^(?<area>.*)-home-(?<action>.*)$", // regex as string extraction methods
        "^xyz\\.(?<action>.*)$"
    )
    .UseRoutes(
        new Route<Context>(StringRouter.Match("action", "create"), b => b
            .Use(async (context, next) => { Console.Write($"Create {context.Feature<Message>().Body}"); await next(context); })),
        new Route<Context>(StringRouter.Match("action", "delete"), b => b
            .Use(async (context, next) => { Console.Write("Delete Hello"); await next(context); }))
    )
    .Build();

await stack(new Context(new Message("xyz.delete", "Hello World")));
````

Public APIs: `IMiddlewareBuilderExtensions` (UseRoutingKey), `StringRouter` (for matching), `RouteData` (behind the scenes)

### Endpoint Routing

Endpoint Routing enables earliers middlewares to understand the routing and the endpoints of later middlewares configuration. The can access the final endpoint (if the necessary data is present to evaluate the route predicates and additional predicates pushed to the endpoints). Built on top of Predicate based Routing, in example here used with String Router.

````csharp
var stack = new MiddlewareBuilder<Context>()
    .UseRouting() // enables endpoint routing
    .UseRoutingKey(context => context.Feature<string>(), "^(?<action>.*)$") // has to be extracted ASAP (without route data no branch evaluation can be done)
    .Use(async (context, next) => {
        context.Feature<EndpointFeature>().TryGetEndpoint(context, out var endpoint); // evaluate branches and determine endpoint
        if (endpoint?.Name == "Foo") { // not possible otherwise
            Console.WriteLine("[LOG] Before Foo Call");
            await next(context);
            Console.WriteLine("[LOG] After Foo Call");
        } else {
            await next(context);
        }
    })
    .UseRoutes(
        new Route<Context>(StringRouter.Match("action", "Hello"), branchBuilder => branchBuilder
            .Use(async (context, next) => { Console.Write("Hello"); await next(context); })
            .Use(async (context, next) => { Console.Write("World"); await next(context); })
            .UseEndpoints(endpoints => {
                endpoints.MapLambda("Foo", async () => Console.WriteLine("Hello World")); // endpoint is constrained by "action = Hello"
            })
        ),
        new Route<Context>(StringRouter.Match("action", "Foo"), branchBuilder => branchBuilder
            .Use(async (context, next) => { Console.Write("I am never called"); await next(context); })
            .UseEndpoints(endpoints => {
                endpoints.MapLambda("Bar", async (context) => Console.WriteLine("Never World")); // endpoint is constrained by "action = Foo"
            })
        )
    )
    .Build();

// for the sake of simplicity, misusing string as a feature
await stack(new Context("Hello"));
````

Each `UseEndpoints` can contain multiple mapped endpoints which can be annotated by additional predicates. `UseEndpoints` which do not having a matching endpoint in it are invoking the next middleware. If they have an applicable endpoint, they execute the endpoint.

````csharp
var stack = new MiddlewareBuilder<Context>()
    .UseRouting()
    .UseRoutingKey(c => c.Feature<string>(), @"^action-(?<action>.*)$")
    .UseEndpoints(endpoints =>
    {
        // map a lambda and require a match with action route data
        endpoints.MapLambda("my-lambda-a", _ => { /* ... */ })
            .Requires(StringRouter.Match("action", "A"));

        endpoints.MapLambda("my-lambda-a", _ => { /* ... */ })
            .Requires(StringRouter.Match("action", "B"));
    })
    .Use(c => { /* only invoked if action is different than A or B */ })
    .Build();

await stack(new Context("action-B"));
````

Public APIs: `IMiddlewareBuilderExtensions` (UseRouting and UseEndpoints), `IEndpointRouteBuilder`, `IEndpointBuilder<TContext>`, `Endpoint<TContext>` `IEndpointRouteBuilderExtensions` (MapLambda), `EndpointFeature<TContext>` (TryGetEndpoint)

### 🏃♂ Experimental ControllerEndpoint

***Note**: This concept is a work in progress. The interface is not stable and may change on minor releases*

The ControllerEndpoint is a endpoint builder extension which allow dispatching a stack against a regular .NET class. Explicit middleware branching is not required as the endpoints can internally push predicates (like controller/action names) before mapping an endpoint.

````csharp
var controller = new TestController(); // singleton, has multiple endpoints as functions

var stack = new MiddlewareBuilder<Context>()
    .UseRouting()
    .UseRoutingKey(c => c.Feature<string>(), @"^(?<controller>.*)/(?<action>.*)$")
    .UseEndpoints(endpoints =>
    {
         // map all public methods as endpoints and register them to controller/action route constraints
        endpoints.MapController(controller);
    })
    .Build();

await stack(new Context(routingKey));
````

Public APIs: `IEndpointRouteBuilderExtensions` (MapController and MapControllerAction).

## Documentation

- [Architecture Log](docs/arch-log.md)
- Inspiraton: [1](https://speakerdeck.com/davidfowl/asp-dot-net-core-architecture-overview)

## Community, Contributions, License

[Code of Conduct](CODE_OF_CONDUCT.md) (🏃♂ Monitored Email Pending)

🏃♂ Contributing Guideline (not yet done)

[MIT licensed](LICENSE)

---

Legend: 🏃♂ In Progress, ⌛ Not Yet Available

repository: violetgrass/middleware

gha_language: C#

repo_name: violetgrass/middleware


text:
# purescript-elmish-html

## 0.7.0

### Added

- `Elmish.HTML.Events` module with more precisely typed events.
- `onTouchXyz` events.
- `img.loading` property.
- `video.onPlay` and `video.onPause` properties.

### Changed

- **Breaking**: All event properties `onXyz` are now typed more precisely than
  just `Foreign`, allowing for event handling without resorting to
  `unsafeCoerce` and/or `readForeign`.

## 0.6.0

### Changed

- **Breaking**: Changed `ref` props from `EffectFn1 elem Unit` to `Elmish.React.Ref`

## 0.5.0

### Changed

- **Breaking**: The `textarea` element no longer allows children. React differs from Html by using the `value` prop instead of a text element child to set the input state. https://reactjs.org/docs/forms.html#the-textarea-tag
- No longer using Elmish FFI mechanism for HTML tags

## 0.4.0

### Changed

- **Breaking**: Changed `ref` props from `String` to `EffectFn1 elem Unit`

## 0.3.0

### Changed

- migrated to PureScript 0.14
- migrated to Elmish 0.5.0 (`JsCallback`s are gone, replaced by `EffectFn`s)

## 0.2.1

### Changed

- migrated to GitHub Actions

## 0.2.0

### Changed

- migrated to Spago

## 0.1.4

### Added

- `onEnded`, `onError`, `onLoadedMetadata`, `onTimeUpdate`, `onVolumeChange` props for `<video>`

## 0.1.3

### Added

- `onDoubleClick` prop for all elements

## 0.1.2 — February 28, 2020

### Added

- `img.onError` prop

## 0.1.1 — February 28, 2020

### Changed

- Give `onXyz` events a parameter (where makes sense)

### Added

- Add `onScroll` event, which was missing
- Export a convenience `_data` function so that consumers don't have to import `Foreign.Object.fromHomogeneous`

## 0.1.0 — February 28, 2020

### Added

- Add support for HTML `data-` attributes via special `_data :: Object String`
  `props` on all HTML components.
- Add support for CSS frameworks in `Elmish.HTML.Styled`
- Add a way to construct values of type `CSS`

## 0.0.3 – May 23, 2019

### Added

- Add CircleCI configuration.
- Add Spago configuration.

## 0.0.2 – May 23, 2019

### Added

- Add `README.md`.

## 0.0.1 – May 9, 2019

- Initial release.

repository: collegevine/purescript-elmish-html

gha_language: PureScript

repo_name: collegevine/purescript-elmish-html


text:
# Kadira APM

Meteor Development Group has bought Kadira APM from Arunoda. We have made the original Kadira code available under the MIT License in this GitHub repository.

As the code we're running in Galaxy has diverged, we will not be running this repository as an open source project. We've started a conversation with potential maintainers of a community fork.

Arunoda uses the name Kadira for other projects and still owns the trademark on the "Kadira" name. Arunoda requests that public forks should choose a new name.

The Meteor Development Group along with Arunoda, has archived the code at [kadira-open/kadira-server](https://github.com/kadira-open/kadira-server).

## Branches

- A significant branch is [lampewebdev/kadira-server](https://github.com/lampewebdev/kadira-server). It contains some limited package version updates for minimal operation capability.

- Oregon State Police is working with the ''kadira-open'' code base for use on a stand-alone localhost system [shathaway/kadira-server](https://github.com/shathaway/kadira-server).

- NodeChef provides an APM service for Meteor.

- MontiAPM provides an APM service for Meteor.

# kadira-open/kadira-server

This is a set of components you need to run Kadira in your system.

> The following instructions are not production deployment configurations. It's meant for running for testing.

## Initial Setup

Open `init-shell.sh` and update configurations.
Make sure to set fresh DB configurations before getting started.

Then run following three components by visiting their directories:

* kadira-engine
* kadira-rma
* kadira-ui

## Connecting with Kadira Agent

You you are ready to connect your app into Kadira. Since we are running with a custom setup, you need to export following environment variable before using Kadira in your app:

```
export KADIRA_OPTIONS_ENDPOINT=http://localhost:11011
```

> Here's we've assumed http://localhost:11011 as the kadira-engine URL.

This is the endpoint you enter into your Meteor project when instrumenting with either:

- meteorhacks:kadira

- mdg:meteor-apm-agent.

repository: shathaway/kadira-server

repo_name: shathaway/kadira-server


text:
YCSB workloads generation, created by YJ
----------------------------------------

- Schema

    * YCSB: Single table with 10 million records (11 columns with 1 primary-key, which is the column number from 1 to 10 million, column and 10 extra columns with valid value in first column only. Details and dump of table created by DBx1000 could be found in folder /img/YCSB_table.dump)

    * **Comments from Xiangyao**:
        1. There are 10 columns but the values are NULL except the first column whose value is "hello". The schema is defined in benchmarks/YCSB_schema.txt. For the concurrency control study in our papers, *the values do not really matter so we didn't model them carefully*. - To achieve atomic operations maybe?
        2. The YCSB workload in DBx1000 is *different from the original YCSB workload*. We made these changes to make the workload more interesting to study concurrency control algorithms.
        3. The schema won't be changed. Actually, the value does not really matter. Right now for YCSB we only *model the writing behavior but always write 0 to the rows*.

- Transaction
    - Table size: config_table_size/partition_count
    - Model: Zipf (0 < theta < 1 is the skew) from paper - Quickly Generating Billion Record Synthetic Databases
    - Query: Single Key/Value query with Zipf-generated uint64 rowid and randomly generated value - rint <= 256
    - Transaction: default 16 queries per transaction. Can be altered
    - GetNextQuery: &queries[q_idx++]/run_txn - Sequential Access for query and transaction

- Storage (in memory)

    - Claim: 10GB database with Single table and 10 million records (1024 x 1024 x 10 rows)
    - Reality: 300\~\~500 MB database with default settings since there is no other columns excpet the first one, like key/value pair
    - Each row (tuple) has a single primary key (hash index)
    - Each row has 10 additional column of 100 byte randomly generated string data each (char) rand() % (1<<8) by the paper
    - 10GB = (1024 x 1024 x 10) x (10x100)

- Workflow
    - Warmup the DB by running # transaction(s) first
    - Choose workloads (YCSB/TPCC/TEST)
    - Import schema from benchmarks/YCSB_schema.txt
    - Populate one single table with 10 million records in which the primary key is 1, 2, 3 ... 10m
    - For each row, there is a manager object to handle rts, wts, lock & release
    - Initialize transactions with 16 YCSB queries each
    - For each transaction, there is a int64 txnid and transaction manager
    - Initialize thread list with THREAD_CNT

- Patch
    - ycsb_txn.cpp - line 72
    - In the previous implementation, the data being modified hadn't been written back to the table.

    ~~~c++
    //------------------Patch No. 1----------------------//
    //------------------ADDED BY YJ----------------------//
    row->set_data(data, 8);
    //------------------ADDED BY YJ----------------------//
    ~~~

license: ISC


text:
---
layout: essay
type: essay
title: Saying Hello
date: 2016-08-26
labels:
  - Learning
  - Goals
  - Software Engineering
  - IT
---

## Hello World

A "Hello is a beginning of something new. Relationships start with a "Hello". Usually they are followed by an introduction and hopefully with a smile. A "Hello" can start a conversation or it can start a passion. In my intoductory class to computer science, our first assignment was to make our computer say "Hello World!". Mostly all introductory classes do it, and it may seem really simple but to me it filled me with excitement. Being able to tell a computer to do anything I want and it will do it is incredible. When I am programming I feel as if I am talking to the computer and when the program runs exactly as I expect it to I feel like the computer understood me.

## My future

Of course, not everybody can "talk" to a computer. Programming a hard language to learn so in the future I would love to be that translator. I strive to be an IT specialist in the future. I would love to know more about computer and programming so I can help other people use that information. Even if I do not become an IT specialist, being able to know how to develop software, web, and applications is fun! I have always wanted to try video game development because I am able to tell the computer to make a whole different kind of world! That is amazing!

Overall, I may sound like a big nerd to others but programming is something I am passionate about. There is more to programming then just sitting down and typing 0's and 1's. Developing software requires communicating with people, being able to understand others and being able to understand the computer as well. I plan to develop these skills so I can help others in the future. I may develope a program that may change everyday life, or I might be able to tell companies what type of products to use in their buisness. There are so much I can do to help this world now and in the future, and to think that all of this started with just one Hello.


text:
# Test Adapters

GTest Adapter is a trampoline that launches gtest binaries, parses output and
translates it to fuchsia.test.Suite protocol. This will be ported into a runner.

## Building

```bash
fx set core.x64 --with //src/sys/test_adapters/gtest
fx build
```

You can build it with fx but it doesn't give much value. Look at [usage](#usage)
section for real value of this trampoline.

## Usage

Lets take an example. A simple normal v2 test will look like

BUILD.gn
```gn
import("//build/package.gni")

executable("bin") {
  output_name = "simple_example"
  testonly = true
  sources = [
    "simple_example.cc",
  ]

  deps = [
    "//src/lib/fxl/test:gtest_main",
  ]
}

package("simple_example") {
  testonly = true
  deps = [
    ":bin",
  ]

  tests = [
    {
      name = "simple_example"
    },
  ]

  meta = [
    {
      path = "meta/simple_example.cml"
      dest = "simple_example.cm"
    },
  ]
}
```

cml file
```cml
{
    "program": {
        "binary": "bin/simple_example",
    },
    "use": [
        {
            "service_protocol": "/svc/fuchsia.logger.LogSink",
        },
    ],
    "expose": [
        {
            "service_protocol": "/svc/fuchsia.test.Suite",
            "from": "self",
        },
    ],
}
```

Above example test will implement `fuchsia.test.Suite` and expose it. To run
gtests without modification, you need to wrap your test in the trampoline. See
below for modified build and cml file.

BUILD.gn
```gn
import("//build/package.gni")

executable("bin") {
  output_name = "simple_example"
  testonly = true
  sources = [
    "simple_example.cc",
  ]

  deps = [
    "//src/lib/fxl/test:gtest_main",
    "//src/sys/test_adapters/gtest", # added dep
  ]
}

package("simple_example") {
  testonly = true
  deps = [
    ":bin",
  ]

  # added gtest_adapter to bin/
  binaries = [
    {
      name = "gtest_adapter"
    },
  ]

  tests = [
    {
      name = "simple_example"
    },
  ]

  meta = [
    {
      path = "meta/simple_example.cml"
      dest = "simple_example.cm"
    },
  ]
}
```

cml file

```cml
{
    "program": {
        // use gtest to run your test
        "binary": "bin/gtest_adapter",
        // pass test as argument
        "args": ["/pkg/test/simple_example"]
    },
    "use": [
        {
             // gtest adapter needs this
            "service_protocol": "/svc/fuchsia.process.Launcher",
        },
        {
            "service_protocol": "/svc/fuchsia.logger.LogSink",
        },
        { // gtest adapter needs this
            "directory": "/tmp",
            "rights": ["rw*"],
        },
    ],
    "expose": [
        {
            "service_protocol": "/svc/fuchsia.test.Suite",
            "from": "self",
        },
    ],
}
```

After these changes you can just run

```
fx run-test simple-test
```

And your test will run as a v2 test.

## Limitations

Currently test adapter doesn't support:

- Disabled tests.
- Tests writing to stdout, those tests can be executed but stdout is lost.

These limitations would be either fixed in this adpater or once we port it to
runners.

## Examples

Two examples to demonstrate how to write v2 test

- [Complex test (injects echo service)](tests/echo-example)
- [Simple test](tests/simple-example)

## Testing

Run:

```bash
fx run-test gtest_adapter_tests
fx run-test gtest_adapter_integration_test
```

repository: opensource-assist/fuschia

repo_name: opensource-assist/fuschia


text:
# Taller 2 parte 1

## Project setup client

### Pre requirements
You must have npm and vue installed

### npm intallation
Here is a guide for installing npm
https://nodejs.org/es/download/package-manager/

### vue installation
After installing npm, just run the `npm install vue` command

If you want to have a view of the project with a graphical interface, you can install vue cli with the following command `npm install -g @vue/cli`

### Project setup
1. Clone the repository.
2. You will find the `package.json`. You can run `npm i` to install the dependencies.

### Dependencies

* vuex
* vuetify
* vue-router
* vue
* sass-loader
* connect-history-api-fallback
* core-js

### DevDependencies

* babel-eslint
* eslint
* eslint-plugin-vue
* vue-template-compiler

### Scripts

* Compiles and hot-reloads for development `npm run serve`
* Run vue graphic interface `vue ui`
* Compiles and minifies for production `npm run build`
* Lints and fixes files `npm run lint`

## Project setup server

### Pre requirements
* You must have java 11
* Maven installed

### Dependencies
* jaxws-ri
* jersey-container-grizzly2-http
* jersey-hk2
* gson
* jersey-media-json-jackson
### Run and project settings
* Clone the repository
* Open the terminal in the directory where you cloned this repository
* run the command `mvn clean install exec::java`

## Back-end URL's

### Get all the trips
http://localhost:3000/API/trips

### Get specific trip using the Id
http://localhost:3000/API/trip?id=...

### Creates a new trip
http://localhost:3000/API/create_trip

post method that accepts a JSON with the following structure:

```
{
    "name":"paseo",
    "place_departure":"Med",
    "place_arrival":"Bog",
    "date":"2020-10-10"

}
```

### Deletes a trip using the id
http://localhost:3000/API/delete_trip/{id}

### Updates a trip name
http://localhost:3000/API/update_trip_name?id=..&name=..

### Updates a trip place of arrival and place of depature
http://localhost:3000/API/update_trip_place?id=..&arrival=..&depature=..


text:
# <%- projectname%>

The programming language that has been chosen is golang.

## Install and Setup GO
Download and configure your workspace with latest version of Go and correct environment path.

Then:
```
git clone https://github.com/ricardo-ch/<%-projectname %>
cd <%-projectname %>
```

## Run the API
```
go run main.go
```

repository: andriylesch/generator-yogo

repo_name: andriylesch/generator-yogo


text:
---
title: "Moving to eclipse"
date: 2021-07-12T21:22:22+01:00
---

We started to move the many parts of the furo project from theNorstroem to eclipse last month.

This forced us to restructure the individual parts of *furo*.
The restructuring definitely brings us some advantages for the project itself.

For the consumers, the sharp separation of the involved components,  a cleaner naming and improved documentation will
give them a better view of the big picture.

We kept the changes that you have to made as low as possible.
Please read in the guide below, what you have to do, to migrate your project.

## Migration guide:

### Web related stuff:
There are no changes to make, all npm packages have the same name.

### API and spec related stuff:
All you have to do is

- Rename the `.spectools` file to `.furo`.
- Replace the word `spectools` with `furo` in the renamed file.
- Update the dependency to the `furoBaseSpecs` (if you have) to at least `git@github.com:theNorstroem/furoBaseSpecs.git v1.27.1`.
- If you work with BEC, install the latest or at least `1.27.3` by running `docker pull thenorstroem/furo-bec:v1.27.3` and you are done.
- If you work with a local installation, update the brew tap and run `brew install furo` and you are done.
- If you installed furo from the source, checkout `github.com/eclipse/eclipsefuro`.

{{< hint info>}}
**Note on nested spces**
If you have dependenies which are not already switched from spectools to furo, you have to rename the `.spectools`
file to `.furo` in your dependency folder.
{{< /hint >}}

### Custom generators
If you have built custom generators for `furoc`,
change the dependencies for spectools and furoc to at least `github.com/eclipse/eclipsefuro v1.27.3`

	github.com/theNorstroem/furoc  becomes github.com/eclipse/eclipsefuro/furoc
	github.com/theNorstroem/spectools becomes github.com/eclipse/eclipsefuro/furo

repository: ekmixon/eclipsefuro

repo_name: ekmixon/eclipsefuro


text:
# Phong Reflection Model

Full light renderer with materials types, light types and textures.

## Getting Started

First clone the project, then you'll need to setup a server to load the textures.

Just get started, it's easy to change the materials and mess with it.

### Prerequisites

A modern browser with Web-Gl compatibility.

## Built With

* [WebGl](https://www.khronos.org/webgl/) - 3D graphics API
* [glMatrix](http://glmatrix.net/) -  Matrix and Vector library
* [Javascript](https://www.javascript.com/) - Language

## Authors

* **Victor Vaquero Martinez** - *Initial work* - [VictorVaquero](https://github.com/VictorVaquero)

## License

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

repository: VictorVaquero/phongmodel

repo_name: VictorVaquero/phongmodel


text:
# friendbug

Friendbug is an app that provides you WhatsApp messages so you can contact friends.

It uses Golang as a main programming language, Redis as a primary database and Twilio for the integration with WhatsApp.

I was used primarily to help me keep in touch with friends, and to try out Golang and Redis

## Setup

To get things started, you need the following things:

* [A Twilio account](https://www.twilio.com/login)
* Your WhatsApp linked to the Twilio account
* A heroku account
* A persistent instance (e.g. [Redis to go](https://elements.heroku.com/addons/redistogo) )
* A scheduler to trigger the code (e.g. [Advanced scheduler](https://elements.heroku.com/addons/advanced-scheduler) )
* A list of friends to contact in the redis instance in the following format
    * Redis list name: `friends`
    * Friends structure in a JSON object
        * name (name of the friend)
        * dateContacted (the last day that you contacted a friend)
        * contactFrequency (integer, plus minus how many days you want to contact this friend)
* An .env file with the following variables
    * TWILIO_ACCOUNT_SID
    * TWILIO_AUTH_TOKEN
    * TWILIO_SOURCE_NUMBER (the Twilio number)
    * TARGET_NUMBER (your number)
    * REDISTOGO_URL

You can also host this on another platform than Heroku, but then the deployment scripts are not provided.

## Installation

Prerequisites:

* A Heroku account
* A Redis account
* A Twilio account

Actual installation:

1. Clone the repository
2. Create the .env file with the correct variables
3. Create a `friends` list in Redis, and populate it with friends
4. Deploy to Heroku
5. Run a one-off dyno with `friendbug`

To run it locally, go `go install` and then execute `friendbug`.

## Notes

**Important**: Because the WhatsApp of Twilio is still in Beta, it cannot send a number a message unless that number has sent the Twilio number a message in the last 24 hours. I suggest you sent `Thank you` back every time it reminds you to contact friends :).

repository: AntonDeMeester/friendbug

repo_name: AntonDeMeester/friendbug


text:
# The Call Stack and Debugging

## Definations

> call stack is a mechanism is to keep track of its place in a script that calls multiple functions — what function is currently being run and what functions are called from within that function ,uses the Last In, First Out (LIFO) principle

call stack is a data structure that temporarily store and manage function calls

> n summary, then, we start with an empty Call Stack. Whenever we invoke a function, it is automatically added to the Call Stack. Once the function has executed all of its code, it is automatically removed from the Call Stack. Ultimately, the Stack is empty again.

The call Stack is single and When the functions called and executed one in the time that means that the call stack is synchronous

In Asynchronous JavaScript there will be maybe and event or loop or some functions that tacks too long running

## LIFO:

the last function add is the first to pop up.

Ex:

`function firstFunction(){`
  `throw new Error('Stack Trace Error');`
`}`

`function secondFunction(){`
  `firstFunction();`
`}`

`function thirdFunction(){`
  `secondFunction();`
`}`

`thirdFunction();`

## Temporarily store

As in the previous example the function `secondFunction` stores the value of `firstFunction();` till it returns to it.

it always keep the order of the functions to be executed next and where the values goes

## What causes a stack overflow?

> A stack overflow occurs when there is a recursive function (a function that calls itself) without an exit point.

as soon as the browser reach the maximum stack calls it will send an error instead.

## Types of error messages

- **Reference errors** when you forgot to declare the variable mate. or you declared them after calling them.

- **Syntax errors**  this occurs when you have something that cannot be parsed in terms of syntax

- **Range errors** giving a wrong length for an array or a nigative value

- **Type errors** trying to us ehelping functions made for data type to another that is not allowing to.

## Debugging

you can use `console.log()` the values you want to check in to know it is value at some point

or you can use the chrome avaliable tools after pressing right click then inspect you choose the source tab

choose the data you want to follow up it allows for much more control.

## Handling errors

there is alot of ways to handle errors but one of them is to use the try and cath method

in the try you will be executing all the functions in it

in order then it will if all of them ran smoothly without error it will jump over the catch function and ignore all of it's contant.

but if try failed to execute one of it's functions

the JS will run the catch metod with the functions inside and ignore and forget all the values and functions in the try method.

it may be used to show the messege (404 not found) or (sorry somthing went wrong) but is is better than a not working page at all.

## Tools to avoid runtime errors

**quokka** to evaluate your code as you type

**eslint** to make sure your style guide is consistency and it will grab you an error or two along the way


text:
# HIBP offline check
![GitHub](https://img.shields.io/github/license/landsil/haveibeenpwned-password-check)

## What it does
These scripts let your users query an offline file with SHA1 passwords taken from [Have I been Pwned](https://haveibeenpwned.com/Passwords)

The file is too big to open normally (obviously), but can be checked in under two minutes on a reasonable machine.

The format is: `HASH:NUMBER`
 - eg. `11:22` is `17BA0791499DB908433B80F37C5FBC89B870084B:22`

The hash is **upper case**, the number is how many times this password appears in the database.
The file is ordered by hash.

The script assumes the file is named `p_hash.txt` and sits next to the script in the same folder.
Currently it holds two scripts, one in bash, one in python 3, works on Linux; a Mac version will require commenting out a few lines.

## Learning / Code examples
#### [check_hash.sh](https://github.com/Landsil/haveibeenpwned-password-check/blob/master/check_hash.sh) contains:
 - `WHILE *** DO` / `IF *** THEN *** ELSE`
 - Reading password, replacing characters with `*`
 - Hash data
 - Searching for string in file with `grep`
 - Tracking work time

#### [check_hash.py](https://github.com/Landsil/haveibeenpwned-password-check/blob/master/check_hash.py) contains:
 - `getpass.getpass` automated setup for taking passwords
 - Hashing and re-formating
 - `WITH xxx FOR *** IF`


text:
---
layout: post
date: 2021-07-08
categories: debugging, windbg
title: List of WinDbg commands
---

## Help ##

`.hh {command}`
: show help for command

## Symbols and modules ##

`.sympath`
: show the symbol search path

`ld {module-name}`
: (re)load symbols for a module

`lm`
: list all modules

`lmvm {module-name}`
: dump information about a specific module

`x {module-name}!{function}`
: resolve a native function address, wildcards accepted

`ln {address}`
: find nearest symbol

## Processes and Threads ##

`|`
: processes list

`|{process-num}s`
: switch to another process

`.childdbg 1`
: enable child process debugging

`~`
: list all threads

`~{thread-num}s`
: switch to another thread

`~*{command}` or `~e!{ext-command}`
: execute command on all the threads [^6]

## Call stack ##

`k [{number of frames}]`
: show the native call stack

`~*k`
: show native call stacks for all threads

`!uniqstack`
: group threads call stacks and avoid duplicates

`.frame [/c] {frame-number}`
: switch to another call stack frame

## Variables ##

`dv [{pattern}]`
: display local variables, need to have private symbols

`? {expression}` and `?? {c++-expression}`
: evaluate an expression

`r [{registry-name}]`
: dump register value

## Memory ##

`d{format} {address}`
: dump memory in specific format

`db {address}`
: bytes and ascii

`dp {address}`
: pointer size

`dps {address}`
: display addresses and symbols referencing them [^1]

`dt {type} {address}`
: use specific type layout when dumping memory

`!address {address}`
: show details about a memory region to which the address belongs

`e{format} {address} {value(s)}`
: edit memory [^2]

## Program Execution ##

`u {address}`
: show disassembly

`uf {address}`
: disassemble a function

`g`
: continue

`gu`
: continue until function finishes

`t`
: step into code/assembly

`l+t`
: enable source stepping

`p`
: step over

`{g|t|p}a {address}`
: step until a specific address

`wt -l1 -oa -or`
: watch trace a function

## Debugging events ##

`sxe [-c {cmd1}] [-c2 {cmd2}] {exception|event}`
: enable a given exception or event [^3]

`sxd {exception|event}`
: enable only 2nd chance notification (unhandled exceptions)

`gn`
: mark exception as handled

## Breakpoints ##

`bl`
: list all breakpoints

`bp {address|function-name} [{command}]`
: create a breakpoint

`b{e|d} {breakpoint-number}`
: enable/disable breakpoint

`bc {breakpoint-number|*}`
: remove breakpoint

`[~{thread-num}]ba {access}{size} {address} [{command}]`
: create data breakpoint [^4]

## Visualisation ##

`dx {expression}`
: navigate through debugging objects [^5]

`.nvload {filename}`
: load type visualsation settings

## Managed Code ##

`.chain`
: show loaded extensions

`.loadby sos coreclr`
: load SOS for .Net core

`.loadby sos clr`
: load SOS for .Net Framework

`!sos.help {command}`
: SOS help

`!dumpdomain`
: list app domains

`!dumpmt {address}`
: dump a method table

`!dumpclass {address}`
: dump class detalis

`!dumpmd {address}`
: dump method descriptor

`!name2ee {module}!{type-or-method}`
: resolve a class name into method table, or method name into descriptor

`!bpmd {module} {method}`
: create a method breakpoint

`!bpmd -md {md}`
: create a method breakpoint

`!bpmd {source-file}:{line-number}`
: create a method breakpoint

`!bpmd -list`
: list breakpoints

`!bpmd -clear {breakpoint-number}`
: remove breakpoint

`!bpmd --clearall`
: remove all breakpoints

`!eeheap [-gc] [-loader]`
: show information of clr memory

`!dumpheap -stat`
: show managed heap stats

`!dumpheap -mt {mt}`
: dump objects of a method type

`!dumpheap -type {typename}`
: dump objects of a type

`!dumpobj {address}`
: dump a managed object

`!gcroot {address}`
: see references to an object

`finalizequeue`
: show objects registered for finalization

`!threads`
: list all managed threads

`!clrstack`
: show managed call stack of current thread

`!dumpstack`
: show complete call stack of current thread

`!dso`
: show managed objects in the call stack

`!pe`
: show exception details

`!dumpil {md}`
: dump IL code for a method

`!ip2md {address}`
: match assembly instruction with MD

`u {md|address}`
: disassemble a method or code address

## Examples ##

[^1] : `dps @rsp`

[^2] : `eb 0x123456 'n' 'e' 'i' 'l'`

[^3] : `sxe clr`

[^4] : `ba r4 0x12345`

[^5] : `dx -r1 Debugger.Sessions`

[^6] : `~*e!clrstack` - show all managed callstacks for all threads

gha_language: Ruby


text:
# gaussian

## What does this do?

It's a library that implements gaussian integers.
Gaussian integers are complex numbers a + bi where a and b are integers.

## Why not use arithmoi's `Math.NumberTheory.Quadratic.GaussianIntegers`?

This incurs less dependencies and has a `Num` instance

repository: schuelermine/gaussian

repo_name: schuelermine/gaussian


text:
[Menu](../README.md) [Home](./home.md)
# Bill of material workflow: Boms

Here we will show you how to:
1. Verify the BOM
1. Transfer the BOM

## Requirments

Important to read first:
1. The [[basics|BOM-Workflow]]
1. The [[item workflow for the BOM|BOM-Workflow-Items]]

## Verify the BOM

1. Click on an assembly in Vault
1. Click on the tab "ERP BOM"
1. The "ERP: Bill of Material" dialog will appear
1. Hit the "BOM Transfer.." Button
1. The [BOM Dialog](https://www.coolorange.com/wiki/doku.php?id=powergate:bom_window) will show the Inventor structured BOM
1. **Click on the "Boms" tab**
1. Click on "Check" to verify if all BOM headers and BOM rows
1. If BOM rows are on "Error" state, then hover with the mouse on the error icon and fix it manually

For the [[BOMS mapping, see here.|ERP-BOM-Mapping]]

#### Bom rows

| State| When |
| - | - |
| Different | Quantity is different |
| Remove | The ERP row exists only in ERP but was deleted in the Vault BOM |
| Error | No ERP item is linked |

#### Bom headers

| State| When |
| - | - |
| Different | Any sub row has a modification |
| Error | Any sub row has a no ERP item linked |

Solving an `Error`:
1. Hover with the mouse over the error icon
1. Read the tooltip message
1. Fix manually, for instance, set mandatory Vault UDPs

### Transfer the Inventor BOM to ERP

#### Requirments:

+ Check of BOMs was executed
+ No BOMs on `Error`

1. After verifying all BOMs _(above steps)_
1. Click on "Transfer" to fix the states in "New", "Remove" and "Different" automatically
1. If everything is green on `Identical` then the BOM is successfully deployed to ERP
1. You can display the current [[ERP BOM inside Vault|BOM-Display]]

Items with the state:
+ `New` are transferred with the [[items mapping, see here.|ERP-Item-Mapping]]
+ `Different` are updated with the following properties:
  + Description

![image](https://user-images.githubusercontent.com/36075173/84385257-9004f980-abef-11ea-98c8-1119900b1fcb.png)

repository: coolOrangeLabs/powerGateTemplate

gha_language: PowerShell

repo_name: coolOrangeLabs/powerGateTemplate


text:
---
title: Books I Read in 2015
layout: post
tags:
 - reading
 - books
 - peterthiel
 - 0to1
 - google
 - billwalsh
 - amazon
 - jeffbezos
 - ericschmidt
 - stevejobs
---

As 2015 comes to a close, I start to look back and reflect a bit on what I did / accomplished this year.

One of those things is taking a look at what I read. Below is a list.

__1. [Zero to One](http://www.amazon.com/Zero-One-Notes-Startups-Future/dp/0804139296/)__

This book evolved from [a set of notes](http://blakemasters.com/peter-thiels-cs183-startup) that [Blake Masters](https://twitter.com/bgmasters) published from a Stanford class [Peter Thiel](https://en.wikipedia.org/wiki/Peter_Thiel) was teaching on startups.

Peter is an incredibly broad thinker with some fairly contrarian views on how to build the future. The book is great and challenged some of the ideas that I held about starting up. Anyone starting up should give it a read.

__2. [The Everything Store](http://www.amazon.com/Everything-Store-Jeff-Bezos-Amazon/dp/0316219282/)__

The birth and rise of Amazon with a focus on Jeff Bezos. A great look into a fascinating leader -- his ability to think incredibly long term and his discipline in maintaining such a supreme focus on the customer is second to none.

While I thought it was an interesting book, MacKenzie Bezos (Jeff's wife) didn't take too kindly to it and wrote a pretty [harsh review of the book here](http://www.amazon.com/review/R2I0T26SV0ELPP/ref=cm_cr_pr_perm/?ie=UTF8&ASIN=0316219266&linkCode=&nodeID=&tag=). Still, a fun read.

__3. [The Score Takes Care of Itself](http://www.amazon.com/Score-Takes-Care-Itself-Philosophy/dp/1591843472/)__

[Bill Walsh's](https://en.wikipedia.org/wiki/Bill_Walsh_%28American_football_coach%29) leadership lessons. A football legend that took the worst team in the NFL (the 49ers) and completely revamped the organization, leading them to win 3 championships.

It's fairly football heavy, but filled with practical advice that is applicable to all leaders (even if you don't like football). The man's precision and attention to detail is amazing.

__4. [High Output Management](http://www.amazon.com/High-Output-Management-Andrew-Grove/dp/0679762884/)__

Easily top 5 management books of all time. Written by [Andy Grove](https://en.wikipedia.org/wiki/Andrew_Grove), one of the greatest technology CEO's to ever live. A very detailed and tactical look at what management is and how to become the best.

Anyone (tech or not) leading & managing people needs to read this book. I wrote up [my own summary here](/2015/07/01/high-output-mgmt/).

__5. [How Google Works](http://www.amazon.com/How-Google-Works-Eric-Schmidt/dp/1455582344/)__

[Eric Schmidt](https://en.wikipedia.org/wiki/Eric_Schmidt) (former Google CEO) and [Jonathan Rosenberg](https://en.wikipedia.org/wiki/Jonathan_Rosenberg_%28technologist%29) (former Google SVP of Products) recount their experience building Google and what they learned about building digital products in the internet age.

A great read for anyone working in technology. I wrote up [my summary here](/2015/05/25/how-google-works/).

__6. [Naked Statistics](http://www.amazon.com/Naked-Statistics-Stripping-Dread-Data/dp/039334777X/)__

Naked Statistics explains how stats work in a simple and fun way. Charles Wheelan is great at providing tangible examples that make stats relatable to anyone. Some of the topics are a bit rudimentary, but still a worthwhile and fun read.

__7. [Becoming Steve Jobs](http://www.amazon.com/Becoming-Steve-Jobs-Evolution-Visionary/dp/0385347405)__

Brent Schlender, a longtime friend of Steve Jobs, gives us a fascinating inside look at one of the most well known technology leaders of our time.

What I loved about this book was how real it felt. The book shows Steve's struggles & mistakes -- and ultimately how he grew into the leader we all know today. A fantastic read.

__8. [A Short History of Nearly Everything](http://www.amazon.com/Short-History-Nearly-Everything/dp/076790818X/)__

Bill Bryson takes you through a really fun journey exploring literally everything -- the birth of the universe, rise of civilization, etc. An amazing book that covers so much, it will leave you inspired and diving deeper into several of the different topics he explores.

<hr>

So that's what I read in 2015. I've got a long list of books for 2016, and will push that one when I narrow it down. Any thoughts / questions / suggestions, leave it in the comments or [drop me a line](https://mail.google.com/mail/u/0/?view=cm&fs=1&tf=1&to=christopher.e.yin@gmail.com).

One thing I'd like to change is how I read these books. I 'read' a lot of these as audiobooks (when driving, on the train, etc), which is super accessible and convenient. But I wasn't able to take notes as well and found myself constantly physically re-reading bits and pieces to remember some of the finer details. So planning on doing more reading on the Kindle for 2016. Thoughts, ideas, let me know!

repository: ChrisEYin/kactus

repo_name: ChrisEYin/kactus


text:
---
title: Blog for 04-11-17
layout: post
author: rocco.fattouki
permalink: /blog-for-04-11-17/
source-id: 1d7eb6LSn74FH99k5J-O59QfOf99oHHCbCDyKOhyZI60
published: true
---

    Title
    Blog with Scratch making Space Invaders
    Date
    04/11/17

    Starting point:
    Coded the bullet and the spaceship but needed to code the Alien Mothership.

    Target for this lesson?
    To code the needed programming for the alien mothership.

    Did I reach my target?
    Yes. I managed to include basic info and more obscure.

    How did you use your learning habits this week?

    Persevering
    I didn't know how to code the mothership but after several cases of trial and error I did it.

    Questioning?
    I asked my friends if they could help me with one of the chunks of coding.

    Independence
    I added code that wasn’t necessary and improved my work in different ways.

    Reflecting
    After coding two other sprites I could pick bits that were good and implement them in to this sprite.

    Engagement
    I listened to sir as he walked us through all the logic of the coding.

    What could have gone better in your learning?

    If I’d included more reflecting that would be great as then I would know more about this.

    What changes do you need to make to improve your learning next time?

    Perhaps if I could add a bit more listening.


text:
# HLS test with Video.js

## How-to

 - install Node if not already on your system
 - install grunt: `npm install -g grunt-cli`
 - run `npm install` in root dir to install all dependencies
 - run `grunt`
 - open `localhost:9999` in your browser

repository: boyomarinov/hls-video-test

repo_name: boyomarinov/hls-video-test


text:
# Cupertino Back Gesture example app

Demonstrates how to use the [Cupertino Back Gesture](https://pub.dev/packages/cupertino_back_gesture) package.


text:
# Doctest: Test interactive Haskell examples

`doctest` is a small program, that checks [examples in Haddock comments]
(http://www.haskell.org/haddock/doc/html/ch03s08.html#id566093).  It is similar
to the [popular Python module with the same name]
(http://docs.python.org/library/doctest.html).

## Installation

`doctest` is available from
[Hackage](http://hackage.haskell.org/cgi-bin/hackage-scripts/package/doctest).
Install it, by typing:

    cabal install doctest

Make sure that Cabal's `bindir` is on your `PATH`.

On Linux:

    export PATH="$HOME/.cabal/bin:$PATH"

On Mac OS X:

    export PATH="$HOME/Library/Haskell/bin:$PATH"

On Windows it's `C:\Documents And Settings\user\Application Data\cabal\bin`.

Fore more information, see the [section on paths in the Cabal User Guide]
(http://www.haskell.org/cabal/users-guide/installing-packages.html#paths-in-the-simple-build-system).

## Usage

Below is a small Haskell module.
The module contains a Haddock comment with some examples of interaction.
The examples demonstrate how the module is supposed to be used.

    module Fib where

    -- | Compute Fibonacci numbers
    --
    -- Examples:
    --
    -- >>> fib 10
    -- 55
    --
    -- >>> fib 5
    -- 5
    fib :: Int -> Int
    fib 0 = 0
    fib 1 = 1
    fib n = fib (n - 1) + fib (n - 2)

(A comment line starting with `>>>` denotes an _expression_.
All comment lines following an expression denote the _result_ of that expression.
Result is defined by what an
[REPL](http://en.wikipedia.org/wiki/Read-eval-print_loop) (e.g. ghci)
prints to `stdout` and `stderr` when evaluating that expression.)

With `doctest` you may check whether the implementation satisfies the given examples, by typing:

    doctest Fib.hs

You may produce Haddock documentation for that module with:

    haddock -h Fib.hs -o doc/

### Using GHC extensions

The easiest way to tell Doctest about GHC extensions is to use [LANGUAGE
pragmas] [language-pragma] in your source files.

Alternatively you can pass any GHC options to Doctest with `--optghc`.

    doctest --options=-cpp Foo.hs

### Hiding examples from Haddock

You can put examples into [named chunks] [named-chunks], and not refer to them
in the export list.  That way they will not be part of the generated Haddock
documentation, but Doctest will still find them.

## Development [![Build Status](https://secure.travis-ci.org/sol/doctest-haskell.png)](http://travis-ci.org/sol/doctest-haskell)

Join in at `#hspec` on freenode.

Discuss your ideas first, ideally by opening an issue on GitHub.

Add tests for new features, and make sure that the test suite passes with your
changes.

    cabal configure --enable-tests && cabal build && cabal test

### List of Contributors

See the [list of contributors](https://github.com/sol/doctest-haskell/contributors).

[named-chunks]: http://www.haskell.org/haddock/doc/html/ch03s05.html
[language-pragma]: http://www.haskell.org/ghc/docs/latest/html/users_guide/pragmas.html#language-pragma

repository: technogeeky/doctest-haskell

extension: markdown

repo_name: technogeeky/doctest-haskell


text:
<!--
N.B.: This README was automatically generated by https://github.com/YunoHost/apps/tree/master/tools/README-generator
It shall NOT be edited by hand.
-->

# Wekan for YunoHost

[![Integration level](https://dash.yunohost.org/integration/wekan.svg)](https://dash.yunohost.org/appci/app/wekan) ![](https://ci-apps.yunohost.org/ci/badges/wekan.status.svg) ![](https://ci-apps.yunohost.org/ci/badges/wekan.maintain.svg)
[![Install Wekan with YunoHost](https://install-app.yunohost.org/install-with-yunohost.svg)](https://install-app.yunohost.org/?app=wekan)

*[Lire ce readme en français.](./README_fr.md)*

> *This package allows you to install Wekan quickly and simply on a YunoHost server.
If you don't have YunoHost, please consult [the guide](https://yunohost.org/#/install) to learn how to install it.*

## Overview

Trello-like kanban

**Shipped version:** 5.93~ynh1

## Screenshots

![](./doc/screenshots/screenshot.jpg)

## Disclaimers / important information

* There is currently **no SSO integration** though it might be integrated at some point in the app, now that it's supported in Meteor/Wekan. In the meantime, users can create accounts (in fact, they can create infinite number of accounts) manually, and need to login manually specifically in Wekan.
* This app **only works on x86, 64bits architecture**! In particular, it won't work on 32 bit machines or ARM. See the discussion [here](https://github.com/YunoHost-Apps/wekan_ynh/issues/1#issuecomment-401612500).
* YunoHost users with more than one email address can't login to wekan using ldap. For example first YunoHost user has severals email addresses: root@domain; admin@domain; webmaster@domain; postmaster@domain, etc... Workaround: remove all mail aliases of the user you want to connect, connect one time on wekan, recreate the aliases of the YunoHost user.

## Configuration:
As LDAP authentification is enabled by default, Wekan admins correspond to the permission `Wekan Admin`. The user you choose during installation is member of this group.
To add an admin account, you can:

- [with the webadmin] go to Users > Groups and permissions > Add the user to the permission `Wekan Admin`
- [or with the command line] `yunohost user permission update wekan.admin -a the_user_to_add`

All others YunhoHost user can access with LDAP authentication.

If you have disable ldap authentication, first registered user will be admin, and next ones normal users. If you want other admins too, you can change their permission to admin at Wekan Admin Panel.

**Private/Public mode:** In private mode, only authorized YunoHost members can access to the Wekan.

## Documentation and resources

* Official app website: https://wekan.github.io
* Upstream app code repository: https://github.com/wekan/wekan
* YunoHost documentation for this app: https://yunohost.org/app_wekan
* Report a bug: https://github.com/YunoHost-Apps/wekan_ynh/issues

## Developer info

Please send your pull request to the [testing branch](https://github.com/YunoHost-Apps/wekan_ynh/tree/testing).

To try the testing branch, please proceed like that.
```
sudo yunohost app install https://github.com/YunoHost-Apps/wekan_ynh/tree/testing --debug
or
sudo yunohost app upgrade wekan -u https://github.com/YunoHost-Apps/wekan_ynh/tree/testing --debug
```

**More info regarding app packaging:** https://yunohost.org/packaging_apps