text:
---
weekly_roundup: true
title: "Roundup: NAND, Spookiness, Personalities, Lambdas, Micro-VMs, Annotations, Infrastructure "
date: '2018-11-30 14:30:00 GMT'
authors:
  - 'Murray Steele'
tags: # (Delete as appropriate)
- Culture

---

## NAND Game - [Murray S](/people#murray-steele)

http://nandgame.com/

A while back, I studied [The Elements of Computing
Systems](http://www.nand2tetris.org/) with the [London Computation
Club](http://london.computation.club/).  The book takes you through the process
of building a computer and writing software on it starting from a NAND gate and
working your way up.  This game covers pretty much the same ground as the first
half of the book (it stops once you have a computer and you don't need to learn
machine code or assembly to continue).  The first puzzle is to build a inverter
using only a NAND gate and the second puzzle you build an AND gate using NAND
and inverters.  Eventually you combine everything to make a computer that can
process commands and store things in memory.  I found it interesting to revisit
the material and see how much I could remember, how much I could work out from
the tools at hand and how much I really needed to think hard about (or look up).
If you've an interest in how computers work this is a fun way to learn, and a
good taster for the material in the book if you want to delve deeper.

## Haunted Forests - [Murray S](/people#murray-steele)

https://john-millikin.com/sre-school/no-haunted-forests

To be honest I'm mostly including this because I think the world of software
could do with tending towards the gothic more than it does, so any article with
a spooky metaphor does it for me.  That it's also an article about another of
my favourite topics in software (to re-write or not, and if so, how?) doesn't
hurt either.

## How to Deal with Difficult People on Software Projects - [Elena T](/people#elena-tanasoiu)

https://people.neilon.software/

It's nice to put different personality types into perspective, which is why I
think this should be renamed to "How to deal with people". I unfortunately
identify a bit with some of them, but each section offers advice on how to
correct some behaviour patterns. I found this helpful and educational at the
same time! Which difficult personality are you?

## Ruby support for AWS Lambda - [Andrew W](/people#andrew-white)

https://aws.amazon.com/blogs/compute/announcing-ruby-support-for-aws-lambda/

As part of a wider announcement about increased language support in AWS Lambda
the much requested support for Ruby has finally arrived.

## Firecracker, a new micro-VM from AWS - [Andrew W](/people#andrew-white)

https://aws.amazon.com/about-aws/whats-new/2018/11/firecracker-lightweight-virtualization-for-serverless-computing/

AWS has open sourced the underlying micro-VM technology in Lambda & Fargate -
given the buzz that's been created over the past few days expect to see it
widely adopted.

## A tribute to YouTube annotations - [Andrew W](/people#andrew-white)

https://waxy.org/2018/11/a-tribute-to-youtube-annotations/

Pretty much everyone hated annotations on YouTube which were routinely abused
for ads, etc. but some people put them to good use. They removed the ability to
create new ones some time ago but in what could amount to an act of cultural
vandalism they're deleting them all on Jan 15. Here Andy Baio takes you through
some of the more creative uses for annotations - just make sure you read the
article before they're deleted.

## 5 Lessons Learned From Writing Over 300,000 Lines of Infrastructure Code - [Elena T](/people#elena-tanasoiu)

https://blog.gruntwork.io/5-lessons-learned-from-writing-over-300-000-lines-of-infrastructure-code-36ba7fadeac1

How to do infrastructure that works for developers. Surprisingly, this isn't the
standard.

## Track of the Week - [Vicky P](/people#vicky-peel)

I started running again a couple of months ago and my friend shared one of her
playlists with me on which was this song. When the running gets tough and this
song comes on it changes momentum, makes me want to dance and puts a smile on my
face. Feel good Friday 😀!

<iframe width="560" height="315" src="https://www.youtube.com/embed/SEDlPDSMwms" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

[Shame, Shame, Shame - Linda Fields](https://www.youtube.com/watch?v=SEDlPDSMwms)

branch_name: refs/heads/production

extension: markdown


text:
Tree Decimation
===============

The Way it Works
----------------

To avoid getting a ginormous parse tree, **Pegged** automatically cuts parts of the generated parse tree. The rule is simple: 'keep only nodes that comes from the grammar rules'. So, given the PEG:

```
Gram:
    A <- B* identifier
    B <- 'b'*
```

Then in a final `Gram` parse tree, there will be only nodes named `Gram.A` or `Gram.B`. `identifier`, as a predefined parser or `'b'` (that is, `literal!("b")`) do not produce nodes in the final output. It's true even for `B*`, a `zeroOrMore!(B)` internally, and which produces a node named `zeroOrMore!(B)` with children named `Gram.B`.

When an external rule is invoked and returns a parse tree, **Pegged** has a look at the name of the returned node. If it's from the grammar rules, the node is kept and the process continues with its children. When the node is deemed external to the grammar, **Pegged** has a look at its children and keeps them only if they are from the grammar rules and so on, recursively. If children nodes are kept in the latter case, they are lifted one level, because their parent node was just skipped.

This process does *not* affect matches. In any case, if a rule consumed part of the input and produced matches, these are kept. Tree decimation is only concerned with the parse tree proper.

I'll try to explain with a diagram. Consider the following parse tree from grammar `Gram`:

```
Gram.A
  |
  +--Gram.B
  |    |
  |    +--Gram.C
  |
  +--identifier
  |
  +--oneOrMore(Gram.D)
       |
       +--Gram.D
       |
       +--Gram.D
```

After decimation, the `Gram.B` branch is kept, the `identifier` node is discarded. When **Pegged** discards `oneOrMore(Gram.D)`, it links the two `Gram.D` nodes to `oneOrMore(Gram.D)`'s parent: `Gram.A`. Which gives us:

```
Gram.A
  |
  +--Gram.B
  |    |
  |    +--Gram.C
  |
  +--Gram.D
  |
  +--Gram.D
```

Keeping Local Nodes / Rules
---------------------------

As described in [[Extended PEG Syntax]], you can use the 'promote/keep' operator, `^` to locally keep a node that would otherwise be discarded. `keep!(T)` inner working is simple: it changes the returned node grammar name to that of the master grammar. The changed node is now a cuckoo and will be skipped by the decimation process.

Discarding Local Nodes / Rules
------------------------------

[[Extended PEG Syntax]] presents another operator, `:` (`discard`), which discards the node from the final output. It's the opposite of `keep`, in that it's used to force the discarding of a node which would otherwise be kept: you want them to parse and consume the input, but *you do not want their captures nor their presence in the final parse tree*. It's useful for begin/end markers, for example. See [[Grammar Examples]] for some grammars using `:`.

A second operator, `;` is used to drop a node, *but* keep its match in the final result. I recently realized I commonly had this need.

The `~` operator, which concatenates the matches also drops the children nodes and acts as a kind of cutting operator. I designed it this way because I realized that everytime I wanted to glue rule matches together, I was only interested in the global match and never needed the child nodes.

* * * *

Next lesson: [[Extended PEG Syntax]]

* * * *

[[Pegged Tutorial]]

repository: chadjoan/xdc-pegged

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: chadjoan/xdc-pegged


text:
---
layout: post
title: "Synthetic Data Augmentation using GAN for Improved Liver Lesion Classification"
date: 2018-01-08 11:20:36
categories: arXiv_CV
tags: arXiv_CV Adversarial GAN Classification
author: Maayan Frid-Adar, Eyal Klang, Michal Amitai, Jacob Goldberger, Hayit Greenspan
mathjax: true
---

* content
{:toc}

##### Abstract
In this paper, we present a data augmentation method that generates synthetic medical images using Generative Adversarial Networks (GANs). We propose a training scheme that first uses classical data augmentation to enlarge the training set and then further enlarges the data size and its diversity by applying GAN techniques for synthetic data augmentation. Our method is demonstrated on a limited dataset of computed tomography (CT) images of 182 liver lesions (53 cysts, 64 metastases and 65 hemangiomas). The classification performance using only classic data augmentation yielded 78.6% sensitivity and 88.4% specificity. By adding the synthetic data augmentation the results significantly increased to 85.7% sensitivity and 92.4% specificity.

##### Abstract (translated by Google)

##### URL
[https://arxiv.org/abs/1801.02385](https://arxiv.org/abs/1801.02385)

##### PDF
[https://arxiv.org/pdf/1801.02385](https://arxiv.org/pdf/1801.02385)

license: MIT


text:
+++
date = "2012-12-23"
title = "Stormcloud 1.2 Released"
author = "Jono Cooper"
+++

Stormcloud has finally made it into the Ubuntu Software Center (seriously, it was finished like 3 weeks ago). While it's still open source, pre-built packages are available exclusively through the Ubuntu Software Center. It's $2.99 and totally worth it.

## What's new?
Everything. Stormcloud underwent a rewrite. It looks and feels pretty similar but it now has support for multiple locations, chameleonic backgrounds (unity only), credits, touch screen support and many more animations.

On the technical side of things, Stormcloud now uses node-webkit rather than GTKWebkit. This is so there are hardware accelerated animations and the smoothest experience possible. The only downside is that it adds a lot to the download size.

## Why is it $2.99?
Stormcloud 1.1 was free. If you want Stormcloud 1.2 for free, you can download it off [Github](https://github.com/consindo/stormcloud). I'm charging a small fee because I not only want to test how well the Software Center monetizes but earning some money will encourage me to make Stormcloud even more excellent.

You can get Stormcloud from the [Ubuntu Software Center](https://apps.ubuntu.com/cat/applications/stormcloud/).

repository: stayradiated/mintcode

repo_name: stayradiated/mintcode


text:
## go-thumber

go-thumber is a dynamic JPEG thumbnailing proxy designed for speed. It
implements JPEG -> JPEG thumbnailing only.

Features:
* Input: JPEG (YCbCr 4:4:4, 4:4:0, 4:2:2, 4:2:0, and greyscale modes)
* Output: JPEG (YCbCr 4:4:4 or greyscale)
* No color conversion: data is kept in direct planar YCbCr buffers for efficiency and quality
* Optimized JPEG decoding: decodes only as much data as necessary for a particular resolution
* Uses libswscale for very fast but high quality scaling (lanczos)

Unsupported:
* RGB or CMYK modes. The input images are assumed to have been transcoded to a sane format.
* Color-subsampled output. The assumption is that a low-res thumbnail can benefit more from full chroma, so this has not been implemented for simplicity.
* Progressive decode/buffering. While the JPEG encoded data is streamed to/from
  the network, currently the entire raw YCbCr image is buffered before and after
  scaling. This could be changed to work in slices, saving memory.
* Other image formats
* Cropping

### Dependencies

* Go 1.3 (needed for http.Client.Timeout and certain cgo features)
* libswscale (from ffmpeg or libav)
* libjpeg (preferably libjpeg-turbo)

### Build

    $ sudo apt-get install libswscale-dev libjpeg-dev
    $ mkdir -p "${GOPATH}/src/github.com/pixiv"
    $ cd "${GOPATH}/src/github.com/pixiv"
    $ git clone <repo URL>
    $ go install github.com/pixiv/go-thumber/thumberd

On hardened setups which default to PIC builds, the following flag is required:

    $ go install -ldflags '-extldflags=-fno-PIC' github.com/pixiv/go-thumber/thumberd

And the versioning is possible on build-time.

    $ go install -ldflags '-X main.version v1.3' github.com/pixiv/go-thumber/thumberd

### Usage

thumberd is a FastCGI server. You can also run it as a standalone HTTP server
like this:

    $ thumberd -local localhost:8080

And then access a URL of the form:

    http://localhost:8080/w=128,h=128,a=0,q=95/upstream-host.com/some-image.jpg

Parameters:

    w: thumbnail width (required)
    h: thumbnail height (required)
    q: JPEG quality (default 90)
    u: upscale if the source is smaller (default 1)
    a: force thumbnail aspect ratio. If 0, keep aspect (default 1)
    o: optimize JPEG (default 0)
    p: Factor to use when loading downsampled JPEGs. See below for explanation (default 2)

While uncompressing the source JPEG, the JPEG format allows direct loading of a
downscaled version (by partially decoding only enough data from the JPEG to
reconstruct a lower-resolution version). This built-in downscaling is pretty
decent, but not as good as the main lanczos rescaling algorithm used in
go-thumber. The factor parameter allows control over how this feature is used.

Setting the factor to 0 disables this feature and always loads the
full-resolution JPEG and then downscales it to the target size. Setting the
factor to 1 picks the same or higher resolution as the requested target size.
1.5 multiplies the requested size by 1.5, and so on, such that 2 will always
load at least twice the resolution required and then downsample it. Values
between 0 and 1 make no sense, since they will load an image *smaller* than
requested (but you can try them if you want to see what happens). The JPEG
format and libjpeg only allow resolutions of 1/8 through 8/8 (in units of 1/8)
of the original resolution, so this defines a lower bound; the actual resolution
loaded from the JPEG will usually be rounded up.

In practice, 0 provides the highest quality but is not very efficient, 1 is
fastest but noticeably lower quality, and 2 provides practically the same
quality as 0 while still being faster when the image is being scaled down to
~40% or less of its original dimensions. For comparison, ImageMagick seems to
behave as if p=1.

repository: bootjp/go-thumber

repo_name: bootjp/go-thumber


text:
# EcomPodiOS

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

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

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

```ruby
pod 'EcomPodiOS'
```

## Author

35226835<EMAIL_ADDRESS>
## License

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


text:
<!-- ======================================================================
--- Search engine
title:          Actions
keywords:       actions
description:    Actions in md-site-engine.
--- Menu system
order:          50
text:           Actions
hidden:         false
umbel:          false
--- Page properties
id:
document:
layout:         layout-2-left
$-left:         #side-menu
searchable:     true
--- Side menu
side-menu-root:     /documentation
side-menu-header:   Documentation
side-menu-top:      Introduction
side-menu-depth:    2
======================================================================= -->

# Actions

Sometimes there is a need to display some content based on data provided by the
user. Such a simple process usually consists of three steps:

1. A form collecting user input (launcher content).
2. Processing the data sent by the user (action function).
3. Showing a content depending on the result of the previous step (result content).

The first and last steps are provided by content pages, however, the processing
of the input data requires a JavaScript function called action. The next excerpt
shows a very simple form that has a single text input field and a submit button.
Note the action and method properties of the form!

```html
<form class="form-inline search-phrase" action="/actions/task" method="post">
  <div class="form-group">
    <label>Task name:</label>
    <input type="text" class="form-control" name="task"
           maxlength="20" value="{{ob}}{ .task }}">
  </div>
  <button type="submit" class="btn btn-primary">Check it!</button>
  <span class="error">{{ob}}{ .error }}</span>
</form>
```

Let suppose the data of the form will be processed by an action located in the
__/actions/task.js__ file. The action has to be bound to the form. This is
done in the server start up program (`server.js`) using an actions object:

```javascript
/* /server.js */
...
// Set engine routes.
var actions = {
  'POST:/actions/task': '/actions/task.js'
};
engine.setRoutes( app, actions, mode );
...
```

The property names of the actions object have to match to the __method:action__
pairs of the input forms. The method and the colon can be omitted, the default
method is `POST`. The values of the properties define the JavaScript modules that
contain the individual action functions:

#### action( req, ctx, callback )

__req__: The [request](https://expressjs.com/en/4x/api.html#req) object of the [express] framework.
__ctx__: The engine context of the current request, see [Context object].
__callback( resultUrl )__: The callback function the action has to call to signal the end of the action.

__resultUrl__

Type: `string` Default value: `'/404'`

A valid identifier of a content file that displays the result of the action.
Using the `ctx.getPathById( id )` method ensures that the correct localized
content path will be applied.

Let see a very simple example for the action function that receives the input
text of the preceding form:

```javascript
/* /actions/task.js */
'use strict';

// Task action.
function action( req, ctx, callback ) {

  // Read form data.
  var task = req.body.task;
  // Save input data.
  ctx.data.task = task;

  // Process data.
  if (task.length > 5) {
    // Pass result data.
    ctx.data.result = task.length;
    // Display result.
    callback( ctx.getPathById( '/tasks/task-result' ) );
  }
  else {
    // Show error message.
    ctx.data.error = 'Input text is too short!';
    // Stay on form page.
    callback( ctx.getPathById( '/tasks/task-form' ) );
  }
}

module.exports = action;
```

Actions land on ordinary content files, and data are passed through the
`ctx.data` object. The passed data are available on the contents and segments
by a context token, where the token name is the name of a property on the
data object, and it is preceded by a dot: `{{ob}}{ .property-name }}`. For
example using the previous sample action:

```html
<p>
  <label>Task name:</label> <span class="success">{{ob}}{ .task }} characters</span>
</p>
<p>
  <label>Length:</label> <span class="success">{{ob}}{ .result }} characters</span>
</p>
```

### Built-in actions

The engine has the following built-in actions:

URL | Description | See
--- | ----------- | ---
/404 | It is called when a content is not found. |
/set-language | It is called at changing language. |
/reboot | It can be called to reinitialize the content manager. |
/search | It is called at content search. | [Content search]
/r&d | It can be called in development mode. | [Development support]
<br/>

The URLs of all built-in actions can be set in the `paths` section of the
[configuration].

repository: logikum/md-doc-site

branch_name: refs/heads/develop

gha_language: CSS

gha_license_id: MIT

repo_name: logikum/md-doc-site


text:
This package is forked from thephpleague/factory-muffin-faker, because the [Faker version is not updated](https://github.com/thephpleague/factory-muffin-faker/issues/12).

Factory Muffin Faker 2.0
========================

[![StyleCI Status](https://styleci.io/repos/27880728/shield)](https://styleci.io/repos/27880728)
[![Build Status](https://img.shields.io/travis/thephpleague/factory-muffin-faker.svg?style=flat-square)](https://travis-ci.org/thephpleague/factory-muffin-faker)
[![Coverage Status](https://img.shields.io/scrutinizer/coverage/g/thephpleague/factory-muffin-faker.svg?style=flat-square)](https://scrutinizer-ci.com/g/thephpleague/factory-muffin-faker/code-structure)
[![Quality Score](https://img.shields.io/scrutinizer/g/thephpleague/factory-muffin-faker.svg?style=flat-square)](https://scrutinizer-ci.com/g/thephpleague/factory-muffin-faker)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE)
[![Latest Version](https://img.shields.io/github/release/thephpleague/factory-muffin-faker.svg?style=flat-square)](https://github.com/thephpleague/factory-muffin-faker/releases)
[![Total Downloads](https://img.shields.io/packagist/dt/league/factory-muffin-faker.svg?style=flat-square)](https://packagist.org/packages/league/factory-muffin-faker)

The goal of this package is to wrap [Faker](https://github.com/fzaninotto/Faker) to make it super easy to use with [Factory Muffin](https://github.com/thephpleague/factory-muffin).

Note that this library does not actually require Factory Muffin in order to work, so may be used else where too. The whole point of this library is to wrap Faker in closures so the actual generation can be executed at a later point.

## Installing

[PHP](https://php.net) 5.4+ and [Composer](https://getcomposer.org) are required.

In your composer.json, simply add `"lubobil1990/factory-muffin-faker": "^2.0"` to your `"require-dev"` section:
```json
{
    "require-dev": {
        "lubobil1990/factory-muffin-faker": "^2.0"
    }
}
```

## Usage

Documentation coming soon.

## Contributing

Please check out our [contribution guidelines](CONTRIBUTING.md) for details.

## Credits

Factory Muffin Faker is a wrapper around [Faker](https://github.com/fzaninotto/Faker) to make it super easy to use with [Factory Muffin](https://github.com/thephpleague/factory-muffin), and is currently maintained by [Graham Campbell](https://github.com/GrahamCampbell). Thank you to all our wonderful [contributors](https://github.com/thephpleague/factory-muffin-faker/contributors) too.

## License

Factory Muffin Faker is licensed under [The MIT License (MIT)](LICENSE).


text:
# HackingFacebook

Bypassing Facebook for iOS's SSL Pinning, allow us to capture decrypted HTTPS request send from Facebook, with tools like [Charles](https://www.charlesproxy.com/).

![Screen Shot](https://raw.githubusercontent.com/Naituw/HackingFacebook/master/screenshot.png)

## Description

This repository shows how to kill the certificate pinning in [Facebook for iOS](https://itunes.apple.com/cn/app/facebook/id284882215?mt=8) **without** Jailbreak your device.

I've successfully captured decrypted https requests from Facebook with Charles by apply this patch. I tested the currently newest Facebook for iOS version 79.0, this patch may become invalid with newer version.

## About
- Inspired by https://github.com/nabla-c0d3/ssl-kill-switch2, https://github.com/nabla-c0d3/ssl-kill-switch2/issues/13
- Contents of `DyldPatcher` is created by [depoon](https://github.com/depoon), the original repo is https://github.com/depoon/iOSDylibInjectionDemo, and an article about this<EMAIL_ADDRESS>- The `iResign` is modified version of https://github.com/maciekish/iReSign, created by Maciej Swic. I added support for injected libraries.
- The Aspects library is created by Peter Steinberger, licensed under MIT, the original repo is https://github.com/steipete/Aspects

## Instructions

**Update 20170319**

I've developed a new tool to finish this steps in more simple way, see:

https://github.com/Naituw/IPAPatch

**Original Instructions**

1. Prepare `Facebook_extenstion_removed.ipa`
   - Get decrypted Facebook ipa, wether from  a jailbroken device or ipa download site (I'm using ipa downloaded from http://www.iphonecake.com)
   - Unzip ipa, Remove `Payload/Facebook.app/Plugins` folder, which contains App Extensions.
   - Zip the `Payload` folder, and rename to `Facebook_extenstion_removed.ipa`

2. Inject Code to `Facebook_extenstion_removed.ipa`
   - Build `DyldXcodeProject`, make sure the target is selected to real device (NOT iPhone Simulators), copy the result framework's binary file to a folder named `DyldsForInjection`
   - Use the script provide in `DyldPatcher`, patch the binary we generated, to `Facebook_extenstion_removed.ipa`, the patched file is named `Facebook_extenstion_removed-patched.ipa`

            cd DyldPatcher
            ./patchapp.sh Facebook_extenstion_removed.ipa DyldsForInjection

3. Resign `Facebook_extenstion_removed-patched.ipa`
   - Use the modified version of `iResign` to resign the file, the result file is `Facebook_extenstion_removed-patched-resigned.ipa`, this version will sign the dyld we injected correctly.

4. Install and Run
   - Install `Facebook_extenstion_removed-patched-resigned.ipa` via Xcode
   - Capture HTTPS requests like other apps with `Charles`!

repository: joker-max/HackingFacebook

repo_name: joker-max/HackingFacebook


text:
# get-caller-file

[![Build Status](https://travis-ci.org/stefanpenner/get-caller-file.svg?branch=master)](https://travis-ci.org/stefanpenner/get-caller-file)
[![Build status](https://ci.appveyor.com/api/projects/status/ol2q94g1932cy14a/branch/master?svg=true)](https://ci.appveyor.com/project/embercli/get-caller-file/branch/master)

This is a utility, which allows a function to figure out from which file it was invoked. It does so by inspecting v8's stack trace at the time it is invoked.

Inspired by http://stackoverflow.com/questions/13227489

*note: this relies on Node/V8 specific APIs, as such other runtimes may not work*

## Installation

```bash
yarn add get-caller-file
```

## Usage

Given:

```js
// ./foo.js
const getCallerFile = require('get-caller-file');

module.exports = function() {
  return getCallerFile(); // figures out who called it
};
```

```js
// index.js
const foo = require('./foo');

foo() // => /full/path/to/this/file/index.js
```

## Options:

* `getCallerFile(position = 2)`: where position is stack frame whos fileName we want.

repository: ChromeDevTools/devtools-frontend

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: ChromeDevTools/devtools-frontend


text:
# Fujitsu-AC-Homekit by Homekit Italia Group

A firmware for ESP8266 to use to control Fujitsu Air Conditioner.
the code is based on peros550 ac_multiple_sensors fw using the maxim kulkin's libraries.

A special thanks to [GPL71](https://github.com/GPL71) , [lizzus](https://github.com/lizzus) and [RavenSystem](https://github.com/RavenSystem) for their support.

It's a beta version, it will be update very soon with a complete guide to install and use it.


text:
# Help for Document Editor / Reader

## How do I create a document?

1. open the `Document Editor`
2. Under `Document Settings` in the menu bar, define your output format.
3. Now you can write the document in the specified syntax. For help you can use a
Preview, this is optional and can be disabled.
4. When you are finished, you can save your document in the menu bar under `Document Editor -> Save/Save As`.

> **Note:** Be careful how you save your document, HARD/RAM DISK erases itself after the browser cache is empty. Alternatively you can connect to a `Firebase Storage` with the application `Cloud`.

repository: ThornWalli/web-workbench

gha_language: JavaScript

repo_name: ThornWalli/web-workbench


text:
# Cai McCann | Homework_1 | 1/15/2020

1.	Make sure everything is set up and working on the laptop that you will be using for this course (most current versions of R and RStudio, tinytex package, Typora (a markdown editor), Notepad++, GitHub account)
2.	Learn markdown in Typora.
3.	Create a typora document to illustrate the following formatting:
   •	headers (levels 1-6)
   •	unordered lists
   •	ordered lists
   •	manual line breaks
   •	links
   •	images
   •	block quotes
   •	plain code blocks
   •	R code blocks
   •	in line block
   •	in line LaTeX equation
   •	centered LaTeX equation
   •	horizontal rule
   •	simple table

# Headers

# Header

## header

### header

#### header

##### header

###### header

# Unordered list

* unordered lists
* underordered lists
  * subset unordered list

# Manual line break

###### ^that was a manual line break

# Links

<https://lvash.github.io/Bio381/>

[a very useful website](https://lvash.github.io/Bio381/])

# Images

![Alt text](C:\Users\clmcs\Desktop\McCann_Bio381\pensivecat.jpg)

# Block quotes

> In this first paragraph, it should be noted that Blockquote is a 10 letter word.
>
> >I did another sideways carat for fun.
>
> This is another, second paragraph just for the heck of it.

> I separated out the blockquote just now, using the enter button multiple times to exit from each block quote.

> o
>
> > o
> >
> > > o
> > >
> > > > o
> > > >
> > > > > _____________________________________
> > > > >
> > > > > > o
> > > > > >
> > > > > > > o

# Code blocks...

### (Fenced) Code Blocks == Plain code blocks

```

```

``````

``````

``````
I just made a blank box (similar to a text box)--need 6 back ticks ` or you can use tildas ~
``````

### Code span // non "pre-formatted code block"? == In line blocks

`printf()`

`maybe?`

`insert text between backtick quotes`

```function test() {console.log("notice the blank line before this function?");}```

### R code block

```R

```

** this is coded for R* language specifically

# LaTeX equation fun

### In line LaTeX equation

$z_{n+1}= z*n^2+c$

### Centered LaTeX equation

$$
z_{n+1}= z*n^2 + c
$$

# Horizontal rule

***

---

***

---

# Simple table

| First header                       | Second Header |
| ---------------------------------- | ------------- |
| this is one sleek looking table :) |               |

# Diagrams!

** This is in Mermaid*

We ran through some examples together in class

```mermaid
graph TD
	Start --> Stop
```

```mermaid
graph LR
	A(Start) ==> Stop
```

4 - 9.
- create simple cause-and-effect diagram to illustrate one or two hypotheses from your research. Circles represent variables or measurements. Arrows (which can be labelled) indicate cause and effect directions.

- import the image into your Typora document.

- convert your hand-drawn flowchart into one of these display items and imbed it in your Typora document.

- explore themes and save results

Ok, now my attempt:

	Before:

![Alt text](C:\Users\clmcs\Desktop\McCann_Bio381\flowchart.jpg)

	After:

```mermaid
graph TB
	A(1426 patients ptt from medical record)--> |exclusions| b(185 ptt excluded due to incomplete monitor procedure and medical record) --> c(3 ptt excluded due to never being assessed)

	A --> |cleaned dataset| D(1238 ptt were included in analysis for risk factor of smoking on BMI)
	D --> |smoking| E(higher BMI)
    D --> |no smoking| F(average BMI range)
```


text:
# Changelog

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

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). This project attempts to match the major and minor versions of [stactools](https://github.com/stac-utils/stactools) and increments the patch number as needed.

## [v0.1.2] - 2021-08-20

### Fixed

- Moved s3 to be a dev dependency only ([#6](https://github.com/stactools-packages/alos-dem/pull/6)).
  Includes a manual pin of the **aiobotocore** version to work around https://github.com/dask/s3fs/pull/510, which should be reverted once that PR is released.

## [v0.1.1] - 2021-08-02

### Added

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Aligned platform and instruments fields with best practices.

## [v0.1.0] - 2021-07-29

The initial release of this package.
### Added

- Everything.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Nothing.

repository: wildintellect/alos-dem

repo_name: wildintellect/alos-dem


text:
# Facebook ads to google bigQuery ETL

_ETL based on cloud function (google cloud) that retrieves data from the Facebook Insight API:_
AdsInsights.Field.account_id,
AdsInsights.Field.campaign_id,
AdsInsights.Field.campaign_name,
AdsInsights.Field.adset_name,
AdsInsights.Field.adset_id,
AdsInsights.Field.ad_name,
AdsInsights.Field.ad_id,
AdsInsights.Field.spend,
AdsInsights.Field.impressions,
AdsInsights.Field.clicks,
AdsInsights.Field.actions,
AdsInsights.Field.conversions

ETL uploads this data to Google Bigquery every day.

## Getting Started

These instructions will get you a copy of the project up and running on your google cloud project for development and testing purposes.

- Secrets are loaded using the google cloud secrets API
  FACEBOOK_APP_ID
  FACEBOOK_APP_SECRET
  FACEBOOK_APP_TOKEN

### Installing

Create scheduler for facebook ads ETL:

- Parameters can be passed as JSON String
  project*id: your google cloud project_id
  dataset_id: for example "facebook"
  table_id: for example "fb_stat"
  fb_account_id: your facebook account id without act*
  since: start date - defaults to yesterday
  until: end date - defaults to yesterday

#### Example

```JSON
{
    "project_id": "my_project",
    "dataset_id": "fb_data",
    "table_id": "ac_name",
    "fb_account_id": "number",
    "since": "2020-01-01",
    "until": "2020-02-01"
}
```

## Authors

- **Andrey Osipov** Original Author
- Philipp Rosenbeck

## License

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

gha_language: Python

gha_license_id: NOASSERTION


text:
# maya-crBSEAssist

[![Version](https://img.shields.io/badge/version-1.0.0-green.svg)]()
[![](https://img.shields.io/badge/TWITTER-%40artbycrunk-blue.svg?logo=twitter&style=flat)](https://twitter.com/artbycrunk)
[![Average time to resolve an issue](https://isitmaintained.com/badge/resolution/artbycrunk/maya-crBSEAssist.svg)](https://isitmaintained.com/project/artbycrunk/maya-crBSEAssist "Average time to resolve an issue")
[![Percentage of issues still open](https://isitmaintained.com/badge/open/artbycrunk/maya-crBSEAssist.svg)](https://isitmaintained.com/project/artbycrunk/maya-crBSEAssist "Percentage of issues still open")

A useful little script for showing the index of blendshapes.

**USAGE** :

* Just Source this script, it should open the Blendshape Editor.

* All Blendshape weight will be prefixed with thier index numbers.

* This is useful when adding inbetween targets and you need to specify target index.

* It also increases the text Label size, for reading large blendshape names.

repository: artbycrunk/maya-crBSEAssist

repo_name: artbycrunk/maya-crBSEAssist


text:
# Contributor Guide for Build

This section will outline resources available for contributors.

## Operating Procedures

* [Issue Handling](https://github.com/rubrikinc/welcome-to-rubrik-build/blob/master/contributors/guide/issue-handling.md)
* [Pull Request Submission](https://github.com/rubrikinc/welcome-to-rubrik-build/blob/master/contributors/guide/submitting-pull-requests.md)
* [Labels](https://github.com/rubrikinc/welcome-to-rubrik-build/blob/master/contributors/guide/labels.md)

## Contributing a New Project

* [New Project Guidelines](https://github.com/rubrikinc/welcome-to-rubrik-build/blob/master/contributors/guide/new-project-guidelines.md)

## Miscellaneous

* [Collaborative Development](https://github.com/rubrikinc/welcome-to-rubrik-build/blob/master/contributors/guide/issue-handling.md)
* [Non-Code Contributions](https://github.com/rubrikinc/welcome-to-rubrik-build/blob/master/contributors/guide/non-code-contributions.md)

repository: syllogy/welcome-to-rubrik-build

repo_name: syllogy/welcome-to-rubrik-build


text:
# Outdated IE Alert
Outdated IE Alert is a jQuery plugin that shows a well designed modal box to the visitor who's trying to view your site with an older version of Internet Explorer browser. The modal box encourages your visitors to upgrade their browser for a better experience using your site.

## When should I use it?
You should use it when you created a stunning modern website that looks and works amazing in modern browsers and you don't want to waste your time and money to make it work on legacy browsers like IE6, IE7 and IE8.

## How it works
This plugin will show a modal box to the visitor who is trying to view your website with with an older version of Internet Explorer browser. The modal box tries to convince them to upgrade to a newer version or to an another modern web browser. By clicking the upgrade button a new window/tab will be opened where your visitor can download a new browser. The modal box contains a title text, a basic text, a close button and an upgrade button. This plugin will detect user's idiom and will show texts in respectives idiom (fallback to english idiom).

### Dependecy
jQuery library

### Demo

### Usage
Include jQuery library and then outdated-ie-alert.js and outdated-ie-alert.css files in your HTML document and initialize the plugin:
```html
<!--[if IE]>
	<link rel="stylesheet" href="outdated-ie-alert.css"/>
	<script src="outdated-ie-alert.js"></script>
	<script>
		$(document).ready(function(){
			$("body").outdatedIeAlert();
		});
	</script>
<![endif]-->
```
### Documentation
You can pass an object with the following options:
```javascript
$("body").outdatedIeAlert({
	support : "ie8",
	overlayClose : false,
	closeBtn : true,
	title : ?,
	text : ?,
	upgradeTitle : ?,
	upgradeLink : ?
});
```

`support` (string - optional - default: "ie8")

Defines on which version of Internet Explorer will the modal box appear. Available options:

ie9 - Modal box will appear on Internet Explorer 9, 8, 7, 6.

ie8 - Modal box will appear on Internet Explorer 8, 7, 6.

ie7 - Modal box will appear on Internet Explorer 7, 6.

ie6 - Modal box will appear on Internet Explorer 6.

`overlayClose` (boolean - optional - default: false)

Defines whether the modal should be closed when clicked on the overlay

`closeBtn` (boolean - optional - default: true)

By default user can close the modal box and by doing this he will not upgrade his browser. But you can hide the close button by setting closeBtn to FALSE

`title` (string - optional)

Defines the modal title text. If not specified, this plugin will detect user's idiom and use the following text (translated to user's idiom):

"Did you know that your Internet Explorer is out of date?"

`text` (string - optional)

Defines the modal warning text. If not specified, this plugin will detect user's idiom and use the following text (translated to user's idiom):

"To get the best possible experience using our site we recommend that you upgrade to a modern web browser. To download a newer web browser click on the Upgrade button."

`upgradeTitle` (string - optional)

Defines the upgrade button text. If not specified, this plugin will detect user's idiom and use the following text (translated to user's idiom):

"Upgrade"

`upgradeLink` (string - optional)

Defines the upgrade button link. If not specified, this plugin will detect user's idiom and use the following website (in user's idiom):

http://outdatedbrowser.com

### Credits
Based on https://github.com/nmsdvid/ie-alert

repository: AndersonMamede/outdated-ie-alert

repo_name: AndersonMamede/outdated-ie-alert


text:
# Installation

```
sudo sh install.sh
```

# Modules

## Apps

QT application to monitor device log events:

```
app/android-dev-watcher-qt/
```

## udev

Scripts for udev resides in 'udev' directory.

## Logger

Scripts to handle udev events. Installed by install.sh.

## inotify

Scripts and application for inotify reside in 'inotify' directory.

Build inotify native application:

```
sh inotify/c-api/compile.sh
```

## USB

Scripts for USB resides in 'usb' directory.

## ADB

Scripts for Android ADB resides in 'adb' directory.

# Miscellaneous

Monitor udev registered events:

Less detail:
```
    udevadm monitor
```

More detail:
```
    udevadm monitor --property
```

repository: yileye/device-watcher

repo_name: yileye/device-watcher


text:
* Data
  * Databases
    * [PostgreSQL](./posgresql.md)
    * Cassandra
      * Consistent Hashing
    * MongoDB
    * MySQL
    * DynamoDB
  * Data Streaming
    * Kafka
  * Concepts
    * [SOLID](./solid.md)
    * [ACID](./acid.md)
    * BASE
    * OLAP
    * OLTP
    * Write-ahead Logging
* Architecture
  * Domain Driven Design
  * CQRS
  * Hexagonal Architecture
  * Cellular Architecture
  * Event Sourcing
  * Microservices
  * CAP
  * Service Mesh
  * Service Discovery
  * Communication Protocols
    * HTTP
    * REST
    * gRPC
    * Protocol Buffers
  * Circuit Breaker
  * Compute Infrastructure
    * Serverless
      * AWS Lambda
  * Containers
    * Docker
    * Kubernetes
* Networking
  * Load Balancing
    * L7, L4 load balancers
    * Hashing
  * OSI Model
  * HTTP/2
  * HTTP/3
* Programming
  * Design Patterns
  * Java
    * Java 8
    * Java 11
    * ...
    * Concurrency
    * Working with DBs
      * JDBC
      * JPA
      * Spring Data
      * Hibernate
      * JDBI
      * jOOQ
  * Kotlin
  * Scala
  * JavaScript
  * TypeScript
* Data Structures
  * B-Tree
  * Bloom Filters
* Machine Learning


text:
---
layout: post
title: "The Phoblographer updates Fuji X-T1 review for firmware 4.0"
date: 2015-06-30 12:08:35 +0200
comments: true
categories:
- Photography
- Digital Life
external-url: http://www.thephoblographer.com/2015/06/30/weve-updated-our-fujifilm-xt1-review-for-firmware-4-0/
---

Chris Gampat:

> The new firmware brings with it a large number of autofocus upgrades like new tracking, zone focus, and improved speed to single AF focusing.

> Indeed, the camera is significantly faster to focus, and we almost want to say that it’s about on par with the fastest of Sony’s APS-C mirrorless cameras and Samsung’s NX series. However, it still isn’t at Micro Four Thirds speed.

One of the best things about Fuji cameras is the continued support they get for _years_ after their initial release. Fuji’s firmware updates are usually excellent not only in terms of bug-fixing, but also in terms of improving performance and adding actual new features that improve usability and keep their cameras competitive and relevant for longer. They actually remind me a lot of Apple and iOS in that regard.

Clearly, other manufacturers could learn a thing or two from Fuji here.

repository: analogsenses/source

repo_name: analogsenses/source


text:
# Said-Akbar.github.io
Exercises from web development course. Coursera: https://www.coursera.org/specializations/web-design

CSS assignment 2 web page: https://said-akbar.github.io/CSS/assignment_2/index.html


text:
# Changelog

## [Unreleased]

## [0.3.0] - 2018-10-15
### Changed
- Minimum supported release is now julia 1.0

## [0.2.1] - 2018-09-16
### Fixed
- Fixed `load` for LAZ files by updating type signature

## [0.2.0] - 2018-08-17
### Fixed
- Fixed all deprecation warnings in julia 0.7

### Changed
- Minimum supported release is now julia 0.7
- `epsg_code` no longer returns a Nullable, but a `UInt16`, or `nothing` if not present

## [0.1.0] - 2018-08-15
Final release with julia 0.6 support.
### Fixed
- `scan_angle` is changed from `UInt8` to `Int8` ([4c4ad9](https://github.com/visr/LasIO.jl/commit/4c4ad96ecb590fea73b945e03e605d72edccce09))
### Added
- Include setting of SRS by ESPG-code for projected systems in meters ([#9](https://github.com/visr/LasIO.jl/pull/9))
- Streaming / memory map support ([#10](https://github.com/visr/LasIO.jl/pull/10))

## [0.0.1] - 2017-08-22
### Added
- Registered the first version of LasIO.jl

gha_language: Julia


text:
# Data Structure Editor (DSE)

This is a Web-application for creation of data structures and interface descriptions of IIoT devices.
It can generate source code for application services running on the Arrowhead Framework (https://github.com/arrowhead-f/core-java-spring).
This software has been developed as proof of concepts developed in the Productive 4.0 project (https://productive40.eu/).
It is not production safe code.
One of the next tasks would be to update this concept demonstrator to the newest version of the Arrowhead Framework.

## Scope

In distributed applications like IoT networks, information is exchanged between participants of a communication network by use of symbols.
These symbols may indicate a name (address) or a value of information and they are encoded as patterns of bits and bytes.
The information sink evaluates the symbols received from the information source.
For that purpose, it needs prior knowledge about the semantics of at least some symbols, which can be created by the information source.
Technical systems acting as information source are therefore described e.g. by a description of the server API in a client/server architecture or by descriptions of messages appearing in a publisher/subscriber architecture.

The DSE is a Web application, which allows a forms based description of API's of servers.
Additionally, the DSE provides partial source code (skeletons) for the API implementation of the servers, which is generated based on the API descriptions.
The current version of the DSE uses the a 2020 available version of the Arrowhead Framework (<https://github.com/arrowhead-f/core-java-spring>) as target communication platform.

## Terminology

**Data Structure:**
This is a collection of simple numerical and textual data types, other referenced structs and lists of previously mentioned data types.
All members of the struct are communicated at once.

**Data Block:**
This is a collection of data block members.
Each data block member defines a simple numerical or textual data type, references a data structure or a list of previously mentioned data types.
Data block members are communicated separately and have their own transmission characteristics and further attributes.

**Data Structure and Block Library:**
This is a formal description of data structures and blocks.
An XML schema is used to define the structure of such a library.

**Equipment:**
This is a technical system implementing a server at run-time.

**Equipment Type:**
This is an abstract term used to describe a server at design-time, which is later on deployed on a concrete technical equipment.

**Equipment Type Interface Description:**
This is a formal description of an interface of an equipment type.
It contains references to well defined data blocks.
An XML schema is used to define the structure of such an equipment type interface description.

**Skeleton:**
A skeleton is a part of the server-side source code.
It implements an equipment type interface description.
The business logic has to be added.

## Test environment

We used a development and test environment with following main properties:

  - Kubuntu 18.04 - a KDE-based Linux
  - Git v2.17.1 - version control system
  - Python v3.9.5 - server backend programming language (we didn't used special features of 3.9, so earlier versions of Python3 should work too)
  - Node.js v15.1.0 - frontend programming language (JavaScript)
  - npm v7.0.8 - Node.js package manager
  - Vue.js v2.6.10 - frontend framework
  - Arrowhead Framework - repository https://github.com/arrowhead-f/core-java-spring, commit 7e89135648ab00de68c481fddf0c7a0ac8381afa

You have to follow the steps described in the README file of the Arrowhead Framework repository to get all necessary core services running (serviceregistry, authorization, orchestrator).
It might be necessary to adapt the ./backend/data/generic_application.zip file from a newer version of the demo-car example of the official examples (https://github.com/arrowhead-f/sos-examples-spring), since the development of the Arrowhead Framework is going faster than this application,

## Management of the frontend application

You have to enter the fronend directory:

```
cd ./frontend
```

In this directory you have to install the necessary libraries:

```
npm install @vue/cli
npm install
```

For checking of errors you may lint your program:

```
npm run lint
```

In order to minify and prepare the fronend application for production:

```
npm run build
```

## Management of the backend application

You have to enter the fronend directory:

```
cd ./backend
```

If you use jetbrains PyCharm, then you have to create a virtual environment from inside of this IDE and to install the libraries described in requirements.txt.
For example you can use "Help/Find Action" and search for "Create VirtualEnv", add a new Python interpreter and follow the proposed steps to create a new virtual environment.
Then open "requirements.txt" in PyCharm and near the top line you will be prompted to install the requirements.

In the general case, you should use the standard approach to create a virtual environment and install the requirements:

```
python3 -m venv ./venv
```

Activate the virtual environment:

```
source venv/bin/activate
```

All following commands are considered to be performed in the activated virtual environment.

Update pip:

```
pip install --upgrade pip
```

Install the libraries:

```
pip install -r requirements.txt
```

You can deactivate your environment simply by executing:

```
deactivate
```

## How to use the software

### Preface

The software available here is developed for concept testing within the Productive 4.0 project (https://productive40.eu/).
The concepts to be tested concern the following functions:

  - Defining data structures that can be used later when describing device interfaces.
  - Describing device interfaces using the defined data structures.
  - Generating source code for devices from the descriptions of device interfaces.

Other supporting concepts have been partially implemented.
This concerns e.g. the automated version management of the data structure and device descriptions.
As soon as a new description of data structures or of devices is created, a Git repository is also created at the same time.
Other actions, such as the automated creation of commits after changes to the files, would still need to be added.

Similarly, role-based user management is provided in the backend.
This would allow each HTTP-based REST service on the backend to be assigned which roles can run that service.
For a production deployment, it would need to be decided which roles can run which services.
Also, a list of users would need to be maintained to which appropriate roles are assigned.
Currently, we assume that one logs in as an administrator and operates the application.
Since the application is currently configured to run only on the local machine (localhost), the administrator's password is immediately entered in the corresponding input field.
This would of course have to be changed in productive use.

The following sections describe how the core concepts can be tested with the software available here.

### Starting the server and opening the user frontend

It is assumed that all necessary software libraries of the frontend and backend applications have been installed.

If you want to use the example data structures, blocks and equipment type interface descriptions, then you can unzip the data.zip file, so that the folders "backend", "frontend" and "data" are on the same base folder.
On Linux you could use the following command:

```
unzip data.zip
```

Once you have unzipped the examples, you can play with data structure libraries and equipment type interfaces.
The imaginary "Industrie 4.0 Consortium" (see Library Folders) has some libraries from which at least "Hydraulic Pump" has data structures and blocks.
The "DepartmentHydraulics" (see Equipment Type Interfaces / Repositories) provides an equipment interface description "PumpDescription" with references to data blocks of the "Hydraulic Pump" library.
The "PumpDescription" has a cloud-download button, where you can trigger the code generation and download.

Now you can start the server in the backend directory:
```
source venv/bin/activate
python api.py
```

Then you can call the URL "http://localhost:8081/" in the address bar of a web browser.
In the displayed login dialog the already entered password can be confirmed.
The login password is currently fixed in the file "DataStructureEditor.vue".
This would have to be removed in productive operation.

### Defining data structures and blocks

On the left side of the application you will find a navigation bar.
Data structures and data blocks are defined in the section "Data Structure and Block Libraries".
This concerns in detail:

  - **Library Folders**: This is a folder where the libraries are stored. Version management is also maintained at this level. In large companies, there are often independent organizational units (business units) that develop software independently of one another. However, it is also possible that other companies or standardization organizations define some of the data structures to be used. For such organizational units, one would create appropriate folders. A library can be pulled from a URL (cloud symbol in the "Data Structure and Block Library Folders" line). A push-back is currently not implemented (cloud-up-arrow). You can create (+ sign), select (check symbol), edit (pen symbol) or delete (trash can symbol) a library folder.

  - **Libraries**: A library defines a self-contained set of data structures and data blocks. Such a library is stored in a file. You can create (+ sign), select (check symbol), edit (pen symbol) or delete (trash can symbol) a data structure library.

  - **Data Structure Definitions**: A data structure is comparable to a record in common programming languages (C - struct, Pascal - record, Java/C# - class, ...). A data structure contains members to which simple data types or array data types are assigned. You can create (+ sign), select (check symbol), edit (pen symbol) or delete (trash can symbol) a data structure.

  - **Data Block Definitions**: A data block also contains entries to which data types are assigned. In contrast to the members of the data structures, however, additional communication parameters are assigned to each entry of a data block, e.g. the direction of communication (in/out/in-out) or the transfer characteristic (cyclic, acyclic). So to transmit a complex data structure as a unit one would first define the data structure and then define an entry in a data block whose data type refers to the data structure definition. The transfer parameters are then assigned to this block entry. You can create (+ sign), select (check symbol), edit (pen symbol) or delete (trash can symbol) a data block.

### Defining device interface descriptions

Device interface descriptions are defined in the section "Equipment Type Interfaces".
This concerns in detail:

  - **Repositories**: This is a folder where the equipment interface descriptions are stored. Version management is also maintained at this level. Enterprise business units can maintain their interface descriptions in different of those repositories. A repository can be pulled from a URL (cloud symbol in the "Equipment Description Folders" line). A push-back is currently not implemented (cloud-up-arrow). You can create (+ sign), select (check symbol), edit (pen symbol) or delete (trash can symbol) an equipment description repository.

  - **Equipment Interface Descriptions**: An interface description defines the interface of a technical equipment. It contains references to data blocks defined in the data structure and block libraries. An equipment interface description library is stored in a file. You can create (+ sign), select (check symbol), edit (pen symbol) or delete (trash can symbol) an equipment interface description.

  - **Data Block Instances**: A data block instance is a part of an equipment interface description. They refer to data blocks defined in the data structure and block libraries. You can create (+ sign), select (check symbol), edit (pen symbol) or delete (trash can symbol) a data block reference.

### Generating and testing device interface code

The section "Equipment Interface Descriptions" contains for each interface description an additional 'cloud-arrow-down' symbol.
If you click on it, then it will download a "generic_application.zip" file.
You should extract it in a separate folder.

It contains a modified "demo-car" project from the Arrowhead examples GitHub page (https://github.com/arrowhead-f/sos-examples-spring).

We have not changed much in the structure of the project.
Therefore, the Java source codes are still arranged in the package structure defined by the authors of the demo-car project (apparently by AITIA http://www.aitia.ai/).
For production, this package structure should be adapted anyway by the company generating the source code.

The essential file that was generated is located here:

    application_framework/<description>/src/main/java/ai/aitia/demo/car_provider/controller/GenericEquipmentInterface.java

The two lines are to be understood as a common file path.
The <description> contains the name of the description from which you started the download by pressing the 'cloud-arrow-down'-symbol.

The file "GenericEquipmentInterface.java" contains 3 essential functions:

  - **getData(blockName, entryName)**: This is the method to access the device data. The complex "if" statement contained in it initially returns preset values for the addressed block entry.

  - **getInterfaceDescription()**: This method returns a self-description about all blocks and entries provided by this device.

  - **test()**: This method returns an HTML page that provides links to the self-description and to each block entry of the device. Following the links gives JSON representations of the self-description and the current values of the block entries.

This interface code must now be extended by the device developer.
If, for example, one wants to represent a MODBUS TCP device via Arrowhead services, then one must include a corresponding communication library in the generated Java project (e.g. http://easymodbustcp.net).
Then in the target file "GenericEquipmentInterface.java" the developer must first get the values, e.g. of the MODBUS TCP holding register, in the "getData" method.
Then the "dummy_float64", "dummy_int64", ... values must be replaced by values obtained from the MODBUS TCP data.
This is a very simple way of implementation, which can be further improved e.g. by caching strategies.

## Acknowledgements

The research  work leading to  this demonstrator has received  grants as project Productive 4.0 from the European H2020 research and innovation programme and the ECSEL  Joint  Undertaking under  grant  agreement  no. GAP-737459 – 999978918 as well as from the German Federal Ministry of Education and Research (FKZ 16ESE0185). We are grateful to have been given that opportunity for our research activities.

## References

An article is available about the why, what and how of this tool: Thron, M.; Zipper, H.; Bangemann, Th.: Efficient Engineering of IIoT Systems Based on Interoperability Standards, Materials, Methods & Technologies, Volume 14, 2020; online available: https://www.scientific-publications.net/en/article/1002061/ (last visited 2021-04-30).

## Copyright and License Information

Copyright (c) 2021, Institut für Automation und Kommunikation e.V. (ifak e.V.).
See the LICENSE file for licensing conditions (MIT license).


text:
# [Long Island Train Information](http://alexa.amazon.com/#skills/amzn1.echo-sdk-ams.app.8e0cc1a3-5c5d-4b92-9f32-6cb6351723ce)
![3 stars](../../images/ic_star_black_18dp_1x.png)![3 stars](../../images/ic_star_black_18dp_1x.png)![3 stars](../../images/ic_star_black_18dp_1x.png)![3 stars](../../images/ic_star_border_black_18dp_1x.png)![3 stars](../../images/ic_star_border_black_18dp_1x.png) 8

To use the Long Island Train Information skill, try saying...

* *Alexa, ask choo choo, when is the next train from Penn Station to Mineola*

* *Alexa, ask choo choo, what time does the next train leave to Jamaica from Penn Station*

* *Alexa, ask choo choo for the next train to Penn Station from Ronkonkoma*

This skill returns the next few trains that run from one station to another along the Long Island Railroad (MTA LIRR).  For example, you can say "Alexa, ask Choo Choo when is the next train from Penn Station to Mineola?" and Alexa will return the next 3 trains that depart within the next 3 hours.  Now supporting direct station-to-station trips, as well as trips that include a transfer along the way. Updated to correct error with Mets-Willets Point station.  If you have issues, please fill out the form at this link: https://goo.gl/forms/279wqPN5vpZDyx9m2

***

### Skill Details

* **Invocation Name:** choo choo
* **Category:** null
* **ID:** amzn1.echo-sdk-ams.app.8e0cc1a3-5c5d-4b92-9f32-6cb6351723ce
* **ASIN:** B01CJPJRDE
* **Author:** mookiefdr
* **Release Date:** March 4, 2016 @ 04:13:02
* **In-App Purchasing:** No


text:
## Example 2

This example ataches a random number function and finally use **f_generate_nano_seed()** to extract a seed given an entropy level and finally
extracts 8 Nano Key Pairs and shows private key, public key and their respective nano wallets.

You can generate 2**32 (4,294,967,296) wallets with one single SEED. This example will show only 8 wallet generated by your system.

##### WARNING

Don't use any private keys or SEED's in this example to store your funds. You can generate any SEED using this program. Generate it and keep it safe.
(DON'T TELL ANY PRIVATE KEYS OR SEEDS GENERATED TO ANYBODY). If someone have access of one of your PRIVATE KEYS or SEED your funds will be vulnerable
and can be stolen.

### Compiling this example

```
make
./example2
```

#### Return values

Return values are shown with SEED generated and converted to [Bip39](https://en.bitcoin.it/wiki/Seed_phrase) as well and their respective key pair (Private Key) and
a converted encoded to Base32 Public Key (Nano wallet)

```
Paranoic entropy level is used.

It can take a little longer. Try to move mouse, open programs to increase entropy.

Generating a SEED. It can take a little longer.
Try to move the mouse, open a program, play a music to increase entropy ;)

SEED "3548080A8E1FDFF7030E681EC0615B2C86018C528462770ADF70D72594EBFAD5" successfully generated. (DON'T TELL IT TO ANYBODY).
****************************** YOUR NANO SEED IN ENCODED BIP 39 (DON'T TELL IT TO ANYONE) **********************************************

BIP39 ="crystal doctor actor bring worth wine around snack burst adapt fine flip gas shiver energy middle jacket finger switch purity flock invest twice rain"

 KEEP IT IN A SAFE PLACE !!!

****************************** ========================================================== **********************************************

WALLET NUMBER 0
-----------------------------------------------------------

PRIVATE KEY = "55927F9254E77F77EEF4F88084FDF08C5435D7BB08B15237316817CB809BF7D9" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "03AF949B4F7E39856F6080BCA68785988468CCFCDBF235EC2DC2A67283DCD013"
NANO Wallet nano_11xhkkfnyzjsioqp317wnt5rd866f58hspzk8qp4uio8gc3xsn1mbg77tweg
============================================================

WALLET NUMBER 1
-----------------------------------------------------------

PRIVATE KEY = "58364FA546D1A66A7350217FE4D83EB34B655E08B25CB44E62134E3E8D81F50A" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "6700AFB3E4EBAD4F14F7BF6CB808B61464AA70EFB47426EE424769193853DD0C"
NANO Wallet nano_1sr1oysybtxfbwchhhueq16de756obrgzf5n6uq66jub56w79qae9f1q4yxk
============================================================

WALLET NUMBER 2
-----------------------------------------------------------

PRIVATE KEY = "B6832ACEFA3D5645067EB22D79FE5CCE8F1FCF6A7C17267FD2691F1C11932E0E" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "3DDD149C9FE6CA789C9E761E283C3C579A950A71520B6406DCFD43AA40D62813"
NANO Wallet nano_1hgx4kgbzspch4gbwxiy71y5rowtkn794nidei5fszc5ob1fec1m1xg7ibwq
============================================================

WALLET NUMBER 3
-----------------------------------------------------------

PRIVATE KEY = "B4D2B12FA4FFAA39AACC8C29B5449553ECF10C9A208156A7C419880CB13AB55F" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "0A7AFAD81E76E64EAAE8E6E73DA5DDD0E498EB6600E39485E52324E4B3463387"
NANO Wallet nano_14mtzde3wxq8btogjsq99pkxun96m5ope195kk4ycas6wksneew987b5gdjm
============================================================

WALLET NUMBER 4
-----------------------------------------------------------

PRIVATE KEY = "C1E60C0C6C66C61EB009901DF29CE233BE87A8FC64DF5EE249490C0E19816452" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "0A95461DF5EA2714FD232279EF9CBA982B68975A9C6921D3FD4F2E101312D586"
NANO Wallet nano_14noargzdtj94myk8amsxygdo83df4doo95b69bztmsg41bj7oe85ee5cegs
============================================================

WALLET NUMBER 5
-----------------------------------------------------------

PRIVATE KEY = "E03897AE2D1C4393DA9F324D851980ADFC5A275B2D336155F6DEA4EB07F3E474" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "864B2358A52443DB2555213475D967E0F859F9E1912C81C5A2340C5405B93B35"
NANO Wallet nano_33kd6feccb45uekocabngqephr9rd9wy56bei94t6f1eci4ukgsosd46k7zs
============================================================

WALLET NUMBER 6
-----------------------------------------------------------

PRIVATE KEY = "5F101C17E46A2F355B52BADCF36306FB9A5E9195AF18D5E16FC769680CE3D4E1" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "2BCC95DFE40BF8420CD5FCB3CA74F7D36BC969CD4803B2263E1B68095C0E6FF1"
NANO Wallet nano_1cyekqhya4zraa8fdz7msbthhnuds7nwtk15pam5w8ua37g1wuzjwrd1k99z
============================================================

WALLET NUMBER 7
-----------------------------------------------------------

PRIVATE KEY = "FCDAE91003A1C1C68ADB19996BD8D591CF795C8C796E971BA83BE6631259935D" (DON'T TELL IT TO ANYBODY)

PUBLIC KEY = "19FBA894D8810C175EE5FEA1022E82B03425C17F9D90EDB5B8D8CB36074A8AB9"
NANO Wallet nano_18huo4cfj1ae4xhgdzo31aqa7e3n6q1qz9eixptujp8d8r5no4osnx9ate87
============================================================
```

## Futher readings

- [Bip39](https://iancoleman.io/bip39/)
- [nanotools](https://nanoo.tools/key-address-seed-converter) Amazing tool to test Nano cryptocurrency features.

##### WARNING:
These tools are intended for educational purposes only. Never enter anyy sensitive data when you're connected to the internet! Your funds may be at risk

## License
MIT

repository: devfabiosilva/myNanoEmbedded

repo_name: devfabiosilva/myNanoEmbedded


text:
---
title: "Instructor Steps"
layout: handout
ready: false
---

This page is a work in progress; it is a placeholder for the steps that an instructor needs to take at the start
of the quarter, during the quarter, etc. to manage the undergrad tutor program.

# 2-3 quarters before: Planning

* Plan tutor allocation to courses
    * Determine which course instructors are interested in having tutors
    * Determine which instructors are willing to help with CS190J
    * Determine how many paid tutor slots will be available
    * Determine how many slots will be made available for CS190J
* Put the CS190J lecture section and discusssion sections on the schedule.
   * Avoid times that would conflict with popular undergrad courses for the target audience of paid/CS190J tutors (e.g. required CS courses such as CS130A, CS170, etc.)
   * Avoid all of the discussion and lecture sections for the courses taught by the instructors
   * Schedule "discussion sections" on GOLD as 3 hours that overlap with the discussion sections that are being tutored for.

# Late in the quarter BEFORE: Selection of students

* Make a Google Form to collect info from prospective CS190J students, and from prospective Paid tutors
   * TODO: Link to sample forms for 190J and paid tutors (there is overlap but they are different.)
* Send out advertisements via Undergrad mailing lists, via mailing lists of courses, to selected students, etc. advertising the CS190J course
    * TODO: Link to sample marketing materials.
* Advertise the paid tutor availability to all previous paid tutors, and all students that have previously taken CS190J
    * TODO: Link to sample advert
* Meeting of instructors to select paid tutors and CS190J students.
   * Send info to CS staff to start hiring process for paid tutors
   * Send add codes to CS190J students to get them enrolled.

# Course Design, CS190J AND for individual courses  2-4 weeks before start of quarter

Instructional tasks for CS190J

* Set up Syllabus for CS190J.  Choose how finals will be assigned.
* Set up projects, homeworks, outline of lectures/activities for plenary sessions

Instructional tasks for each course:

* Decide how you want to use the tutors in your course
   * Allocation of tutor hours to discussion sections, vs. open lab time.
   * Whether there will be a specific mapping from tutors to individual students (e.g. mentor groups, teams, etc.) or not
   * Whether/how tutors/mentors will be involved in providing feedback on students work.  Which work? Homework? Programming assignents?  Formative or summative? etc.

# CS190J Plenary Tasks: 1-2 weeks before start of quarter

* Set up Piazza/slack for all CS190J and paid tutors
* Set up Gauchospace.
* IF there is shared open lab time
    * Coordinate a schedule of when tutors (and TAs if applicable) are signed up to be available during those lab times ([link to Example](https://docs.google.com/spreadsheets/d/e/2PACX-1vRuoMhndVzqCkuCouf6Sxq5FFMNu7VMQaQrtB45LspZjMQyoBeb5X5VJP12G3JZcSS3vgYLRSTczIYx/pubhtml?gid=833009799&single=true))
* Get keys to the labs from Benji and plan to make one of the tutors or TAs in charge of opening the room and locking it.

# OPTIONAL per course tasks (at discretion of individual instructor)

* Set up Slack for team
* Include on your course site information about the tutors - pics, bios etc.
   * TO DO : Include samples

gha_language: Ruby


text:
# Leucogyroporus pisciodorus (Murrill) Snell SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Mycologia 34: 408 (1942)

#### Original name
Gyroporus pisciodorus Murrill

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
layout: post
title: "OpenSeq2Seq: extensible toolkit for distributed and mixed precision training of sequence-to-sequence models"
date: 2018-05-25 22:54:38
categories: arXiv_CL
tags: arXiv_CL Speech_Recognition Recognition
author: Oleksii Kuchaiev, Boris Ginsburg, Igor Gitman, Vitaly Lavrukhin, Carl Case, Paulius Micikevicius
mathjax: true
---

* content
{:toc}

##### Abstract
We present OpenSeq2Seq -- an open-source toolkit for training sequence-to-sequence models. The main goal of our toolkit is to allow researchers to most effectively explore different sequence-to-sequence architectures. The efficiency is achieved by fully supporting distributed and mixed-precision training. OpenSeq2Seq provides building blocks for training encoder-decoder models for neural machine translation and automatic speech recognition. We plan to extend it with other modalities in the future.

##### Abstract (translated by Google)
我们提供OpenSeq2Seq  - 一个用于训练序列到序列模型的开源工具包。我们的工具包的主要目标是让研究人员能够最有效地探索不同的序列到序列体系结构。通过全面支持分布式和混合精度培训来实现效率。 OpenSeq2Seq为训练用于神经机器翻译和自动语音识别的编码器 - 解码器模型提供构建模块。我们计划在未来以其他方式扩展它。

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

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


text:
## Contrails

XPMP2 can add contrails to planes. This is achieved by instantiating
one additional object per contrail at the same position as the actual plane.
This object `Resources/Contrail/Contrail.obj` has no tris,
but only holds a reference to a particle system file, `Contrail.pss`.
The contrail is then created through X-Plane's
[particle system](https://developer.x-plane.com/article/x-plane-11-particle-system/).

### Disable

If you don't want contrails at all, you need to return `0` for the two config items
`XPMP_CFG_ITM_CONTR_MIN_ALT` and `XPMP_CFG_ITM_CONTR_MAX_ALT`.
In that case you don't even need to provide the `Resources/Contrail` folder
with your deployment.

### Deployment

If you want to make use of contrails, you need to ship the
`Resources/Contrail` folder with all its 3 files with your plugin.

### Default

By default, ie. without any provision in code, a single contrail will be
generated for jet aircraft flying in an altitude between 25,000 and 45,000 ft.

### Configuration of Automatic Contrails

XPMP2 asks for four contrail-related configuration items, with which
you can fine-tune how XPMP2 automatically generates contrails.
This should be sufficient for most usages, even complex plugins like LiveTraffic
only provide pass-through configuration options for these four parameters,
but no self-development implementation.

Config item | Default | Description
------------|---------|-------------------
`XPMP_CFG_ITM_CONTR_MIN_ALT` | 25000 | Minimum altitude in feet for automatic contrail generation
`XPMP_CFG_ITM_CONTR_MAX_ALT` | 45000 | Maximum altitude in feet for automatic contrail generation; set both min and max altitude to `0` to switch off automatic contrails
`XPMP_CFG_ITM_CONTR_LIFE` | 25 | Default maximum lifetime of contrail puffs in seconds, determines contrail length
`XPMP_CFG_ITM_CONTR_MULTI` | 0 | Boolean: Shall multiple contrails be auto-created (one per engine), or just one?

Keep in mind that contrails, using the particle system, may have the potential
to affect performance. That's why by default just a single contrail is generated.

### More Control

If you need more control and want to direct yourself when how many contrails
are shown, you should switch off the auto-generation by returning `0` to
both `XPMP_CFG_ITM_CONTR_MIN_ALT` and `XPMP_CFG_ITM_CONTR_MAX_ALT`,
and then call either of the following two member functions of `XPMP2::Aircraft`:

- `ContrailTrigger()` tells XPMP2 to check the plane's engine type,
  and if it is jet then a contrail (or even multiple, depending on
  config `XPMP_CFG_ITM_CONTR_MULTI`) are created. This is the function
  internally used by the auto-generation mechanism once a plane is in the
  right altitude.
- `ContrailRequest (unsigned num, unsigned dist_m = 0, unsigned lifeTime = 0)`
  allows even more control by specifying the number of contrails, its spacing,
  and the life time.

Last but not least, there's `ContrailRemove()` to remove contrails.


text:
---
title: "Why it's important to set a bar"
published: true
---

Recently in a job interview a question came up to the usefulness of running warning tools that were completely disabled from producing any warnings. This might seem like a waste of time, but I'm a huge fan of doing this. Why? Well that's what this article is all about.

# Background

I'm a huge fan of clean code and having the build system do all it can to make sure the code stays clean going forward. In the past in Eclipse with Java I've used tools such as PMD and Checkstyle. On top of the build warnings that were normally produced these tools would produce additional warnings for things such as formatting, import ordering, and common anti-patterns. They helped while developing new code to make it match the rest of the source base and keep the quality bar high. This also helped us not slowly add more and more warnings to the code base. Nobody starts a project with a 1000+ warnings, it only gets there over time of adding a small amount per commit, or not fixing deprecated warnings when new versions come out.

# Why?

## Easy of Running

If you have the tools running then whenever it doesn't work, you'll know about it immediately. This is really helpful for when one day if you want to add some checks, it will simply be editing the rules file to allow that happen.

## Subtle nudge to Improve Quality

This encourages engineers to enable some rules themselves and fix them. These kind of tasks are great to tackle when you just want a break from what you are working on, but still want to make the product better. At a previous place of employment one of the senior engineers categorized a bunch of warnings into similar groups and logged tickets for them to get fixed. Then over the next 3 months or so most of the tickets were picked up and the warnings were fixed.

## Do you want to waste your time fixing the same bugs?

You are standing on the shoulders of others who've come before you and you can use there expertise to your advantage. A lot of the more useful rules were created to fix common bugs, do you really want to fix the same bugs people fixed, 5, 10, 15 years ago?

## Clarity, Making it easy on your Brain

You end up reading code much more then writing code. With having the code formatted the same way in each and every file it reduces the cognitive load on your brain of trying to figure things out. It also removes the question when you are adding new code to a file of how to format it.

## Less Nitpicking on PRs

It removes the discussion in pull request reviews along the nit-pickier lines of where brackets should go, and when to add new lines, and how variables and functions should be named, etc. Also when you add a new file, which format should it go in, is no longer a question.

# Arguments Against

## High Risk, Low Reward

Sometimes when turning one rule on it will create hundreds or even thousands of warnings. The poor soul will then have to go all the locations and fix them all. QA hates these kinds of changes as they are low risk but can be stretched across the whole project. You can sometimes mob program these and split the work up across multiple people. Also you could edit the rules files to only apply the rule to specific files.

## Change History Investigation

If you are making large formatting changes to the code the argument is it will make it impossible to find out who made changes to what lines before the format. But, I hardly ever see anybody go back to figure out why someone did something 5 years ago.

## Waste of Time

Isn't this just busy work? I really dislike this argument and view the points above to prove it's not.

## Customer Benefit

This is a tough selling point to a product manager, so I'm going to change the source code around and not produce any new functionality, but potentially break existing functionality. I've found trying to make the changes as small as possible, has been really helpful. Saying the task is going to take half a day is a lot less intimidating then saying a week. Also partially doing this work as a part of other tasks is a strategy I've seen been successful. For example, when you are changing a file, you fix all the warnings in it.

# Conclusion

A small project at work I was on many years ago had about 5000 lines of code and as team we ended up adding a bunch of additional checks when we were compiling. This really helped everyones productivity and made the code base feel like it was ours as a team.  This also made it easier to onboard new team members. I really think it's a great idea to have tools running and ready waiting for the day to be turned on and help you writing cleaner code.

url: https://raw.githubusercontent.com/mike011/mike011.github.io/9b8446a3ce1d1c188d3bbb65d3511446629f05a9/_posts/2020-12-15-why it's important to set a bar.md


text:
# UnitTestRunner
Powershell script to run unit test without an IDE

# Motivation
During my work as .NET software developer, I was annoyed of slow IDE's like Visual Studio or Jetbrains Rider. Visual Studio often hangs and crashes with a huge code base and rider seems to have issues when detecting current test runner state. During my job, I often work with a huge code base and like to run unit tests locally, before pushing my changes to the central repository.
Of course, unit tests will mostly executed within the CI pipeline but I want a test feedback as fast as possible. For big teams, the CI resources like build agents often are limited so the CI feedback to the developer takes a while.

With this repository, I want to share a PowerShell script that helps me to run existing unit tests to ensure that I've not breaking any existing tests.

# Current Features
- Support NUnit Console Runner

# Prospect
- Parallel execution of multiple test assemblies
- Get test runner from nuget
- Support for MSTest

repository: MichaWresche/UnitTestRunner

repo_name: MichaWresche/UnitTestRunner


text:
# # findmybikes -
[![Build Status](https://travis-ci.org/f8full/findmybikes.svg?branch=master)](https://travis-ci.org/f8full/findmybikes)

****
##### note
As stated in the [privacy policy], no personal data is neither collected nor used by #findmybikes.
However, some non personal and non identifiable data is collected and published publicly on Twitter.
You can see the data output on the dedicated bot timeline
#### https://twitter.com/findmybikesdata
This published data is the essence of #ludOScity : smarter cities through smart interactions
with their inhabitants. This data could be used to visualize and/or evaluate bikeshare services.
Anyone, including you, could come up with some idea to use it.

#### Twitter output data format specification

Data is tweeted **when the station closest to you doesn't provide service**. When that happen, #ludOS publishes
a status update through [@findmybikesdata]. This tweet mentions what was the closest station **that could provide you service**.

    #findmybixibikes bike is not closest! Bikes:X BAD at IDIDIDIDIDIDIDIDIDIDIDIDIDIDIDID ~XXmin walk stationnamestationnamestation deduplicateZ
sample *#findmybixibikes bike is not closest! Bikes:7 BAD at f132843c3c740cce6760167985bc4d17 ~2min walk Brébeuf / Laurier deduplicate0*

If some stations were discarded in the selection process (because they'd be closer but could not provide service either)
Tweet replies are generated, providing more details on discarded stations

    #findmybixibikes discarded closer! Bikes:Y CRI at IDIDIDIDIDIDIDIDIDIDIDIDIDIDIDID stationnamestationnamestationnamestationnamestationnam
sample *#findmyvlovbikes discarded closer! Bikes:0 CRI at 962c34a494d29737aa7c534f85566949 10102 - DOUA / G. BERGER*

All status updates (root or replies) are geotagged with the location of the described station.

Station names are provided for readability. Station id is provided by citibik.es API
To retrieve corresponding station data, see the great API and fantastic project : https://citybik.es/#about

-- part of [ludos.city]

[privacy policy]:https://github.com/f8full/findmybikes/blob/276f9927c2611808704af42d069503bfad99dd3d/Privacy_policy.md
[@findmybikesdata]:https://twitter.com/findmybikesdata
[GET IT ON GOOGLE PLAY]:https://play.google.com/store/apps/details?id=com.ludoscity.findmybikes
[ludos.city]:http://ludos.city

gha_language: Kotlin


text:
Returns a single item by iterating through the list, successively calling
the iterator function and passing it an accumulator value and the current
value from the array, and then passing the result to the next call.

Similar to [`reduce`](#reduce), except moves through the input list from the
right to the left.

The iterator function receives two values: *(value, acc)*, while the arguments'
order of `reduce`'s iterator function is *(acc, value)*.

Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse
arrays), unlike the native `Array.prototype.reduceRight` method. For more details
on this behavior, see:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description

@func
@memberOf R
@since v0.1.0
@category List
@sig (a, b -> b) -> b -> [a] -> b
@param {Function} fn The iterator function. Receives two values, the current element from the array
       and the accumulator.
@param {*} acc The accumulator value.
@param {Array} list The list to iterate over.
@return {*} The final, accumulated value.
@see R.reduce, R.addIndex
@example

     R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2
         -               -2
        / \              / \
       1   -            1   3
          / \              / \
         2   -     ==>    2  -1
            / \              / \
           3   -            3   4
              / \              / \
             4   0            4   0

@symb R.reduceRight(f, a, [b, c, d]) = f(b, f(c, f(d, a)))

repository: ikatyang/types-ramda

repo_name: ikatyang/types-ramda


text:
# Troubleshooting IKATS

IKATS may run locally with `docker-compose` (for testing and development purpose only, do not use it in production).
This page gives tips to deal with some common errors you can encounter.

## Port 80 is already used by host

If port *80* is already in use, you can customized `.env` file to change the `${GUI_PORT}` variable to a unused one.
This may happen if you already have a webserver running on your host.

## Portainer

If you need to analyze some logs, a convenient way is to use [Portainer](https://portainer.io/).
Portainer is a docker container management UI.

As a quickstart, to run it just do :

```bash
docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v /opt/portainer:/data portainer/portainer
```

Then go to [http://localhost:9000](http://localhost:9000) to reach the UI page

## Checking logs

- Once Portainer is running, go to the container you need to check.
- On the container details, you can see the `Logs` link. Clicking on it will display a page that prints on screen the STDOUT of the container.

## Image logs content

In order to troubleshoot IKATS, interesting logs are :

- **ikats/pybase**
  - Algorithm run status and failure root cause
- **ikats/datamodel**
  - Connection between hibernate and PostgreSQL database

repository: IKATS/ikats-sandbox

gha_language: Shell

repo_name: IKATS/ikats-sandbox


text:
# Plaza Preprocessing

This is the plaza preprocessing package for [plazaroute](https://github.com/PlazaRoute/plazaroute), responsible for preparing OSM files for optimized pedestrian routing with support for routing through plazas.

## Requirements

* Python 3.6
* [Boost Python](http://www.boost.org/doc/libs/1_65_1/libs/python/doc/html/index.html)

## Install

See [the Docker readme](docker/) for quickly getting up and running without an installation.

```
$ git clone https://github.com/PlazaRoute/plazaroute.git
$ cd plazaroute
$ pip install plaza_preprocessing/
```

## Usage

### Download an OSM file

plaza_preprocessing takes an existing OSM file as an input. Data for Switzerland can be found on https://planet.osm.ch.

#### Updating OSM file

In order to keep the OSM data up to date without redownloading it every time, you can use [pyosmium-up-to-date](http://docs.osmcode.org/pyosmium/latest/tools_uptodate.html) provided by pyosmium. Example to bring [switzerland-padded.osm.pbf](https://planet.osm.ch) up to date:

```
pyosmium-up-to-date -v --server https://planet.osm.ch/replication/hour/ switzerland-padded.osm.pbf
```

You can also do this with Docker without having to install pyosmium. See the [the Docker readme](docker/) for reference.

## Preprocessing

```
usage: plaza_preprocessing [-h] [--config filename] [-v] source destination

Preprocess an OSM file for pedestrian routing over plazas.

positional arguments:
  source             input OSM file to process
  destination        destination OSM file

optional arguments:
  -h, --help         show this help message and exit
  --config filename  specify a config file location. A default config will be
                     created if the path does not exist
  -v                 verbose log output
```

Example:

```
plaza_preprocessing switzerland-padded.osm.pbf switzerland-processed.osm.pbf
```

repository: PlazaRoute/plazaroute

repo_name: PlazaRoute/plazaroute


text:
# [Faktograf](https://faktograf.hr/)

Faktograf is based on sage theme, more about sage below.

## Installation

```
# Create DB
mysql -p -e "CREATE DATABASE fg; CREATE USER 'fg'@'localhost' IDENTIFIED BY 'fg'; GRANT ALL PRIVILEGES ON fg.* TO 'fg'@'localhost'; FLUSH PRIVILEGES;"

# Install code
wget https://wordpress.org/wordpress-4.6.1.tar.gz
tar -xzf wordpress-4.6.1.tar.gz
mv wordpress faktograf
cd faktograf
git clone https://github.com/TransparenCEE/faktograf wp-content/themes/faktograf

echo "Edit db connection params and set $table_prefix  = 'fg_';"
cp wp-config-sample.php wp-config.php
vim wp-config.php

# change site URL to one of your server and load database
# wp-content/themes/faktograf/initialize/sampledata.sql
cat sampledata.sql | sed 's/http:\/\/faktograf\.hr\/site/localhost:82/g' | sed 's/http:\/\/faktograf\.hr/localhost:82/g' | sed 's/home\/faktograf\/public_html\/site/home\/www\/faktograf/g' | mysql fg -u fg -pfg

tar -xvf wp-content/themes/faktograf/initialize/uploads.tar.gz -C wp-content

# Go to your website /wp-admin and login using credentials<EMAIL_ADDRESS>Password1
# Go to your website, it should work! if not you may need a .htaccess file in root of the WP: See http://localhost:82/wp-admin/options-permalink.php

```

## Required plugins:

These required plugins are covered by installation procedure specified above
* [Google Analytics by MonsterInsights](https://www.monsterinsights.com/)
* [Monarch](https://www.elegantthemes.com/plugins/monarch/)
* [Yoast SEO](https://yoast.com/)
* [Wodrfence](https://www.wordfence.com/)
* [WP-Polls](https://wordpress.org/plugins/wp-polls/)

## Know more

Sage is a WordPress starter theme based on HTML5 Boilerplate, gulp, Bower, and Bootstrap Sass, that will help you make better themes.

* Source: [https://github.com/roots/sage](https://github.com/roots/sage)
* Homepage: [https://roots.io/sage/](https://roots.io/sage/)
* Documentation: [https://roots.io/sage/docs/](https://roots.io/sage/docs/)
* Twitter: [@rootswp](https://twitter.com/rootswp)
* Newsletter: [Subscribe](http://roots.io/subscribe/)
* Forum: [https://discourse.roots.io/](https://discourse.roots.io/)

## Theme development

Sage uses [gulp](http://gulpjs.com/) as its build system and [Bower](http://bower.io/) to manage front-end packages.

### Install gulp and Bower

Building the theme requires [node.js](http://nodejs.org/download/). We recommend you update to the latest version of npm: `npm install -g npm@latest`.

From the command line:

1. Install [gulp](http://gulpjs.com) and [Bower](http://bower.io/) globally with `npm install -g gulp bower`
2. Navigate to the theme directory, then run `npm install`
3. Run `bower install`

You now have all the necessary dependencies to run the build process.

### Available gulp commands

* `gulp` — Compile and optimize the files in your assets directory
* `gulp watch` — Compile assets when file changes are made
* `gulp --production` — Compile assets for production (no source maps).

### Using BrowserSync

To use BrowserSync during `gulp watch` you need to update `devUrl` at the bottom of `assets/manifest.json` to reflect your local development hostname.

For example, if your local development URL is `http://project-name.dev` you would update the file to read:
```json
...
  "config": {
    "devUrl": "http://project-name.dev"
  }
...
```
If your local development URL looks like `http://localhost:8888/project-name/` you would update the file to read:
```json
...
  "config": {
    "devUrl": "http://localhost:8888/project-name/"
  }
...
```

### Documentation

Sage documentation is available at [https://roots.io/sage/docs/](https://roots.io/sage/docs/).

## Requirements

| Prerequisite    | How to check | How to install
| --------------- | ------------ | ------------- |
| PHP >= 5.4.x    | `php -v`     | [php.net](http://php.net/manual/en/install.php) |
| Node.js 0.12.x  | `node -v`    | [nodejs.org](http://nodejs.org/) |
| gulp >= 3.8.10  | `gulp -v`    | `npm install -g gulp` |
| Bower >= 1.3.12 | `bower -v`   | `npm install -g bower` |

repository: TransparenCEE/faktograf

repo_name: TransparenCEE/faktograf


text:
---
#excerpt: ""
title: "The global governance of international development: Documenting the rise of multi-stakeholder partnerships and identifying underlying theoretical explanations"
category: ["frontpage", "Articles"]
download: "https://link.springer.com/article/10.1007/s11558-019-09362-0"
coauthors: ["Bernhard Reinsberg"]
---
The global governance of development increasingly relies on multi-stakeholder partnerships
between states, intergovernmental organizations, and non-governmental organizations.
This article takes on two tasks. The first is to describe quantitatively the
institutional evolution of the multilateral development system over the past century.
The second is to juxtapose four rational-institutionalist explanations for why states
establish new organizations as transnational governance initiatives—functionalism,
power-oriented theories, domestic politics, and contextual design. The empirical analysis
probes these explanations using the new Transnational Public-Private Governance
Initiatives in World Politics dataset, which combines several existing data sources to
build the most comprehensive data on different forms of institutionalized cooperation in
global governance. The results lend most support to the contextual design view, while
also yielding support for other accounts. By employing Heckman selection models, the
analysis addresses potential selection bias due to unobserved correlation between state
choices to create a new organization and its design. A qualitative case study further
validates measurement choices and causal mechanisms. These findings have implications
for theories of institutional design and development practice, specifically regarding
the role of intergovernmental organizations in an increasingly interconnected world.

gha_language: SCSS


text:
# Gurt-Frags

Standard fragments for [Gurt](//github.com/learningscience/gurt)

Gurt-Frags provide a set of transforms common to front-end projects including linting, pre-processing, concatenation, revisioning, reference injection and post-processing. Almost no configuration is required and frags mostly filter by file type, imposing few organisational limits on your project structure.

If this module fails to satisfy your project's requirements you are encouraged to extend it with your own. One of Gurt's strengths is the ability to mix and match frags from multiple modules into a single pipeline. For writing your own frags see Gurt's readme, and take a look at this module's tiny ~100 LoC.

## Install

```sh
npm install -g gurt-frags
```

```sh
man gurt-frags
```

## Usage

To write custom frags, see [Gurt](//github.com/learningscience/gurt). For quick start, see below:

**Structure**: Gurt's default `--source` directory is `./code`, gurt-frags also expects `libs` (bower directory), `base` (shared code) and `apps` (project code). These facilitate bower file processing and reference injection order.

```text
└── code
    ├── libs
    ├── base
    └── apps
```

**index.html**: Gurt expects an index.html under the source directory for serving, gurt-frags also targets this file for css and js reference injection. Add the following injection tags to your index.html, the order is important.

```html
<!-- libs:css -->
<!-- endinject -->
<!-- libs:js -->
<!-- endinject -->

<!-- base:css -->
<!-- endinject -->
<!-- base:js -->
<!-- endinject -->

<!-- apps:css -->
<!-- endinject -->
<!-- apps:js -->
<!-- endinject -->
```

**Build**: Gurt `serve` and `build` basically do the same thing with different default chains. Gurt `serve` also watches the source directory for changes and serves up the target directory through browserSync, injecting updated styles.

```sh
# watch source (./code) build into target (./dist) and serve
gurt serve
# reads source (./code) build into target (./dist) and exits
gurt build
```

**That's it!** Build your project off `index.html`, install bower components, put your files in `base` and `apps`. All js and css is automatically injected, _all_ content will pass through to the target directory (defaults to `dist`).

## Contribute

Suggestions and contributions will be considered. When crafting a pull request please consider if your contribution is a good fit with the project, follow contribution best practices and use the github "flow" workflow.

## License

[The MIT License](LICENSE.md)

repository: LearningScience/gurt-frags

repo_name: LearningScience/gurt-frags


text:
# Regression on Boston Housing Dataset

We will use the Boston Housing dataset, which is included in the MLDatasets package. It's derived from information collected by the U.S. Census Service concerning housing in the area of Boston. Target variable represents the median housing value.

## Getting started

To begin, we will load the required packages and the dataset:

```julia
using EvoTrees
using MLDatasets
using DataFrames
using Statistics: mean
using CategoricalArrays
using Random

df = MLDatasets.BostonHousing().dataframe
```

## Preprocessing

Before we can train our model, we need to preprocess the dataset. We will split our data according to train and eval indices, and separate features from the target variable.

```julia
Random.seed!(123)

train_ratio = 0.8
train_indices = randperm(nrow(df))[1:Int(round(train_ratio * nrow(df)))]

train_data = df[train_indices, :]
eval_data = df[setdiff(1:nrow(df), train_indices), :]

x_train, y_train = Matrix(train_data[:, Not(:MEDV)]), train_data[:, :MEDV]
x_eval, y_eval = Matrix(eval_data[:, Not(:MEDV)]), eval_data[:, :MEDV]
```

## Training

Now we are ready to train our model. We will first define a model configuration using the [`EvoTreeRegressor`](@ref) model constructor.
Then, we'll use [`fit_evotree`](@ref) to train a boosted tree model. We'll pass optional `x_eval` and `y_eval` arguments, which enable the usage of early stopping.

```julia
config = EvoTreeRegressor(
    nrounds=200,
    eta=0.1,
    max_depth=4,
    lambda=0.1,
    rowsample=0.9,
    colsample=0.9)

model = fit_evotree(config;
    x_train, y_train,
    x_eval, y_eval,
    metric = :mse,
    early_stopping_rounds=10,
    print_every_n=10)
```

Finally, we can get predictions by passing training and testing data to our model. We can then apply various evaluation metric, such as the MAE (mean absolute error):

```julia
pred_train = model(x_train)
pred_eval = model(x_eval)
```

```julia-repl
julia> mean(abs.(pred_train .- y_train))
1.056997874224627

julia> mean(abs.(pred_eval .- y_eval))
2.3298767665825264
```


text:
## TaskBox

Yet another task manager for terminal. In fact this is a hybrid between
simple editor and simple task manager.

## Why?

I surrender my search for perfect task manager. I practice in Go.

## Features

  * TUI
  * tasklists in [github friendly markdown](TODO.md) format
  * no database backend
  * no lib deps
  * filters
  * undo/redo
  * archive
  * autosave

## Installation

You will need to have [Go](https://golang.org) installed and configured
in your path.

```
git clone https://github.com/smetana/taskbox-go
cd taskbox-go
go get -d ./
go build -o taskbox
```

## Usage
```
./taskbox <filename>
```

repository: smetana/taskbox-go

repo_name: smetana/taskbox-go