text:
# Systemd

The _Systemd_ input plugin allows to collect log messages from the Journald daemon on Linux environments.

## Configuration Parameters

The plugin supports the following configuration parameters:

| Key | Description | Default |
| :--- | :--- | :--- |
| Path | Optional path to the Systemd journal directory, if not set, the plugin will use default paths to read local-only logs. |  |
| Max\_Fields | Set a maximum number of fields \(keys\) allowed per record. | 8000 |
| Max\_Entries | When Fluent Bit starts, the Journal might have a high number of logs in the queue. In order to avoid delays and reduce memory usage, this option allows to specify the maximum number of log entries that can be processed per round. Once the limit is reached, Fluent Bit will continue processing the remaining log entries once Journald performs the notification. | 5000 |
| Systemd\_Filter | Allows to perform a query over logs that contains a specific Journald key/value pairs, e.g: \_SYSTEMD\_UNIT=UNIT. The Systemd\_Filter option can be specified multiple times in the input section to apply multiple filters as required. |  |
| Systemd\_Filter\_Type | Define the filter type when _Systemd\_Filter_ is specified multiple times. Allowed values are _And_ and _Or_. With _And_ a record is matched only when all of the _Systemd\_Filter_ have a match. With _Or_ a record is matched when any of the _Systemd\_Filter_ has a match. | Or |
| Tag | The tag is used to route messages but on Systemd plugin there is an extra functionality: if the tag includes a star/wildcard, it will be expanded with the Systemd Unit file \(`_SYSTEMD_UNIT`, e.g. host.\* => host.UNIT\_NAME\) or `unknown` \(e.g. host.unknown\) if `_SYSTEMD_UNIT` is missing. |  |
| DB | Specify the absolute path of a database file to keep track of Journald cursor. |  |
| DB.Sync | Set a default synchronization \(I/O\) method. values: Extra, Full, Normal, Off. This flag affects how the internal SQLite engine do synchronization to disk, for more details about each option please refer to [this section](https://www.sqlite.org/pragma.html#pragma_synchronous). note: this option was introduced on Fluent Bit v1.4.6. | Full |
| Read\_From\_Tail | Start reading new entries. Skip entries already stored in Journald. | Off |
| Lowercase | Lowercase the Journald field \(key\). | Off |
| Strip\_Underscores | Remove the leading underscore of the Journald field \(key\). For example the Journald field _\_PID_ becomes the key _PID_. | Off |

## Getting Started

In order to receive Systemd messages, you can run the plugin from the command line or through the configuration file:

### Command Line

From the command line you can let Fluent Bit listen for _Systemd_ messages with the following options:

```bash
$ fluent-bit -i systemd \
             -p systemd_filter=_SYSTEMD_UNIT=docker.service \
             -p tag='host.*' -o stdout
```

> In the example above we are collecting all messages coming from the Docker service.

### Configuration File

In your main configuration file append the following _Input_ & _Output_ sections:

```text
[SERVICE]
    Flush        1
    Log_Level    info
    Parsers_File parsers.conf

[INPUT]
    Name            systemd
    Tag             host.*
    Systemd_Filter  _SYSTEMD_UNIT=docker.service

[OUTPUT]
    Name   stdout
    Match  *
```

repository: fluent/fluent-bit-docs

gha_language: Shell

repo_name: fluent/fluent-bit-docs


text:
# Coa
Coa is a text transfer application that runs on terminal. It works by creating a host on the target machine which listens for incoming messages from clients. TCP sockets are used for the connection and the port number is predefined as 8080. After every transfer, Coa will compare checksums between the host and the client to make sure the integrity of the text.

To make the program efficient, a size of the file had been limited to 65536 bytes.

## Usage
### Server
Start a server to listen incoming messages on the target machine:

```
coa -s
```

Additionally, use `--no-save` option if you do not want the message to be saved into a file.

### Client

Sending a message as a command line argument:
```
coa -c [hostname] -m [message]
```

Sending a message as a text file:
```
coa -c [hostname] -f [filename.txt]
```

## Building
If you have `clang`, you can just use the [makefile](Makefile). Otherwise, build all three `.c` files and link them into an executable.

## Author
- Boran Seckin

## Reference
The [tutorial](https://www.cs.rpi.edu/~moorthy/Courses/os98/Pgms/socket.html) I used for the socket setup in C.

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

license: MIT

repository: boranseckin/coa

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: boranseckin/coa


text:
---
layout: post
title: "Moved to GitHub Pages"
subtitle: "Yet Another Beautiful Jekyll Site!"
tags: blog
date: '2018-05-11'
image: /img/avatar-icon.png
---

If you're reading this, then the migration has worked. My blog is now hosted via [GitHub Pages](https://pages.github.com/). Many thanks to Kris Rice for his [Blogger migration blog post](http://krisrice.io/2017-10-06-migrating-my-blog-from-blogger-to-github-pages-with-jekyll/) and [source code](https://github.com/krisrice/krisrice.io) to get me set.

I might move some other stuff under this site as well, namely my notes currently over at [kb.seiler.us](http://kb.seiler.us).

branch_name: refs/heads/master

gha_language: HTML

gha_license_id: MIT


text:
# Day 3

Today is actually the start of Makerpad No Code Fundamentals Course **Week 2**. A few things I did on other days last week are incorporated here, but I was sick so wasn't able to accomplish stuff.

## Done

- [x] worked through a couple git videos on cloning to/and push from local, so I understand better (will attempt local asap on this repo!)
- [x] agonized over my Connected Content project, decided it needs two versions: (1) a local, md-based, internal tool; and (2) eventually a cloud-based or cross-platform app using a db. I decided I will not use this project for my main Makerpad project(s), but I personally need the local, personal tool, so will work on it on the side using Obsidian, git, SSG, and some theming. The cloud-based "public" version will wait.
- [x] instead I will work on a resource directory / reviews site for sustainable travel, for TAs and travelers (membership-based), and start with directories for countries, suppliers, organizations, and TAs. The directory will offer basic information as to sustainable travel efforts for each (TA directory will allow links out to their business sites); and implement reviews/comments so members can keep adding information and experience.
- [x] started this week's training on Disco re: Airtable / Softr (still need to do the automation)

Note: the Sustainable Travel Directory project may ultimately move or share data with my travel agency host per recent discussion; there are also other databases that can be added (e.g. city/region, specific hotels/resorts, etc) plus additional things to do as a sustainable travel membership, for both TAs and travelers (e.g. Q & A and trainings/events).

## Next Steps

- set up prototype Airtable bases for four directories and reviews/comments
- add data from C's document
- sign up for Softr and start playing with the tool; compare with new Airtable Interface!?
- Decide last week's assigments: use Softr landing page and membership sign-up; OR, re-do my business page (take it off Webflow host / export; move to Netlify), and(?) re-think my biz membership for power-up (go free and direct to Heartbeat?)
- review all git repos (including move *this* to local) and Netlify hosted; and check all domains (clean up stuff)
- continue with this week's Makerpad coursework & events
- update projects & notes pages here in my build journal to reflect changes

license: Unlicense,MIT

detected_licenses: Unlicense MIT


text:
~Please note this is only a beta release at this stage~

# Best of ACRV ROS Wrappers

[![Best of ACRV Repository](https://img.shields.io/badge/collection-best--of--acrv-%23a31b2a)](https://roboticvision.org/best-of-acrv)
![Primary language](https://img.shields.io/github/languages/top/best-of-acrv/acrv-ros-wrappers)
[![License](https://img.shields.io/github/license/best-of-acrv/acrv-ros-wrappers)](./LICENSE.txt)

Here lie the ROS wrappers for our Best of ACRV codebases, and a severe lack of documentation.

TODO: gif showing the different services available

More to come.

## Installation

The wrappers are a ROS package, which are installed from source like any other ROS package:

1. Clone this repository into your Catkin workspace (or clone elsewhere, and symbolically link it in):

   ```
   u@pc:~/catkin_ws/src$ git clone https://github.com/best-of-acrv/acrv-ros-wrappers
   ```

2. Re-build your Catkin workspace:

   ```
   u@pc:~/catkin_ws/$ catkin_make
   ```

The wrappers depend on the underlying software (e.g. you can't run the RefineNet wrapper without the [RefineNet package](https://github.com/best-of-acrv/refinenet) installed). We have made the dependency dynamic, which means you don't need to have every piece of software installed to run the wrappers. This means if you only want to run [GGCNN](https://github.com/best-of-acrv/ggcnn) for instance, you can use the wrappers without installing everything else.

For the wrappers to work, you need to ensure that both ROS and your standard Python packages are accessible from the same terminal. In particular, Conda users may need to either adjust search paths (or [install ROS through Conda](https://github.com/RoboStack)) to ensure both ROS and Conda packages work harmoniously.

## Using the wrappers

The ROS package includes two scripts for interacting with available services:

- `start_services` for starting a set of services while dynamically requesting dependencies
- `call_services` as a demonstration of how services can be called

## Adding your own wrappers

TODO: handling passing of runtime parameters to the service implementation!

This package is used to showcase how the [Best of ACRV](https://roboticvision.org/best-of-acrv) software can be used with ROS. But if you decide you'd like to access your own services through this framework, new services can be added through a few simple steps:

1. Declare the input and output for your service by adding a new `.srv` file to the [`./srv`](./srv) directory. Also, add the messages into the compilation process by editing [`./CMakeLists.txt`](./CMakeLists.txt) and [`./package.xml`](./package.xml) as required.
2. Add a Python file implementing your service to the [`./src/acrv_ros_wrappers`] directory. Services are implemented as classes that extend the abstract `Service` class ([`./src/acrv_ros_wrappers/service.py`](./src/acrv_ros_wrappers/service.py)), providing implementations for all required abstract functionality. See [`./src/acrv_ros_wrappers/refinenet.py`](./src/acrv_ros_wrappers/refinenet.py) for an example.
3. Add your new service to the services list declared by `SERVICES` in [`./src/acrv_ros_wrappers/services.py`](./src/acrv_ros_wrappers/services.py). You need to provide an import path to your service class, where input paths are `'<relative_import_path_to_file>.<service_class_name>'`.

repository: best-of-acrv/acrv-ros-wrappers

repo_name: best-of-acrv/acrv-ros-wrappers


text:
---
layout: kanji
v4: 1323
v6: 1421
kanji: 窪
keyword: depression
elements: depression, hole, house, human legs, water, water droplets, water pistol, ivy, square jewel, soil, dirt, ground, soil2, dirt2, ground2
strokes: 14
image: E7AAAA
on-yomi: ワ、ア
kun-yomi: くぼ.む、くぼ.み、くぼ.まる、くぼ
permalink: /rtk/窪/
prev: 窟
next: 搾
---

1) [Raichu] 29-10-2006(245): A depression is a hole in the ground. Water naturally collects there which provides moisture for vines to grow.

2) [stefanot] 30-3-2007(113): The depression in the ground become a trap: the hole was filled with water and covered with ivy.

3) [Stormchild] 29-8-2006(35): The meaning of this character is an indentation in the ground, not emotional depression. It's best to avoid using the latter in your story because it will give you the wrong meaning (keep in mind the eventual goal is to read kanji and understand the actual meaning of them). This particular depression is a hole in the ground that collects water, and ivy is growing out of it.

 At this point, however, she and her unfortunately partner were tangled up in some ivy and couldn't get out. So I filled it with water and watched them both drown.

5) [coinbaahd] 20-11-2011(7): This kanji reminds me of video games. There's a big sink hole in the ground that is now filled with water that you can swim in and vines growing all around that you can climb on.


text:
---
layout: default
---

# 1995-08-10 - PGPFOne article in MacWeek URL

## Header Data

From<EMAIL_ADDRESS>(Ted Byfield)

To<EMAIL_ADDRESS>Message Hash: 2c8eaa111c30e0751c1c183c3b7902b0037a406d575df1e18122b54c8858eb9e

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-08-10 07:38:13 UTC

Raw Date: Thu, 10 Aug 95 00:38:13 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Ted Byfield)
Date: Thu, 10 Aug 95 00:38:13 PDT
To<EMAIL_ADDRESS>Subject: PGPFOne article in MacWeek URL
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

MacWeek News

Aug 7, Vol 9 No 31

"PGPFone locks down phone conversations," by Robert Hess

<http://www.zdnet.com/~macweek/mw_08-07-95/news3.html>

{% endraw %}
```

## Thread

+ Return to [August 1995](/archive/1995/08)

+ Return to<EMAIL_ADDRESS>(Ted Byfield)](/authors/tbyfield_at_panix_com_ted_byfield_)"

+ 1995-08-10 (Thu, 10 Aug 95 00:38:13 PDT) - PGPFOne article in MacWeek URL -<EMAIL_ADDRESS>(Ted Byfield)_


text:
# UnfulfillableQuantity

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**total_unfulfillable_quantity** | **int** | The total number of units in Amazon's fulfillment network in unsellable condition. | [optional]
**customer_damaged_quantity** | **int** | The number of units in customer damaged disposition. | [optional]
**warehouse_damaged_quantity** | **int** | The number of units in warehouse damaged disposition. | [optional]
**distributor_damaged_quantity** | **int** | The number of units in distributor damaged disposition. | [optional]
**carrier_damaged_quantity** | **int** | The number of units in carrier damaged disposition. | [optional]
**defective_quantity** | **int** | The number of units in defective disposition. | [optional]
**expired_quantity** | **int** | The number of units in expired disposition. | [optional]

[[Back to Model list]](../../README.md#documentation-for-models) [[Back to API list]](../../README.md#documentation-for-api-endpoints) [[Back to README]](../../README.md)

repository: clousale/amazon-sp-api-php

gha_language: PHP

repo_name: clousale/amazon-sp-api-php


text:
## API Review

### Part 1

1. The drawing and graphics is all done on the frontend but relies on the data from the backend. This is flexible because it allows for more independence between the frontend and the backend.
2. The API/Design encapsulates our implementation decisions because the frontend makes the calculations to display the turtle and draw the lines instead of the backend doing all the work.
3. Any errors that may result will be processed by the backend such as improper commands or an error in uploaded code files but these errors will be displayed on the frontend. Having a frontend API method that
gets an error from the backend will allow the frontend to display the error.
4. Our API/Design is good because everything flows in one direction (frontend to backend to frontend). We also tried to decrease the amount of external API's we use and do most of the work using internal API's so that
we can reduce the reliance between frontend and backend as much as possible. I believe a good API is one that can be run without much dependencies.

### Part 2

1. One design pattern that is currently implemented is the MVC (model view controller) where the model is the backend and the view is the frontend/UI.
2. Most excited to work with the backend on implementing the turtle and drawing the lines.
3. Most worried about relying too much on the backend such that progress slows down because we aren't able to work together often. Worried that the smallest changes will throw a large amount of errors.
4. Use Cases:
	1. Display valid command on the screen
	2. Draw a straight line with the turtle
	3. Display error if command contains an error
	4. Change language of the commands
	5. Changing the background color

repository: hyakkali/SLogo

repo_name: hyakkali/SLogo


text:
# Lab 3

Imagine you're applying for a job as a frontend web developer. You will need to understand CSS. Flex box and Grid.

Finland is hiring developers! They need a web site! Your goal is create the page below from the markup provided.

![lab-3](images/lab-3.png)

## Grid Layout

The page is arranged in a grid with 4 columns. One of the cells spans three columns. You can consider this to have 3 rows. The first row contains only the title of the page.

The container element has the class name `dashboard`. Give this a width of 800px and a height of 600px.

## Background images

Notice that each of the cells has a background image. Use the `background-image` property. Use the `background-size` property with value: `cover` to fit the images into the cells. Each cell has a unique class name!

## Arranging cell contents with flex

The content of each cell is arranged with flex. Use `display: flex` on each cell. Luckily each cell uses a class name!

Looking at the image you'll see the contents of each cell is arranged in a column. Use `flex-direction: column` for each grid cell.

Looking at closely at the cells you'll see that each cell arranges the content differently. Some place the content at the top others at the bottom. Use `justify-content` to arrange the elements at top `flex-start` or the bottom `flex-end`.

Notice some of the cells align elements to the left or the right. This is the cross axis. Use the `align-items` property. Use `flex-start` to move them to the left and `flex-end` to push them to the right.

## Images

These beautiful images from wonderful Finland are [here](images/lab-3.zip).

## Page markup

Use the markup below:

```HTML
<!DOCTYPE html>
<html>
<head>
  <title>Finland</title>
  <style>

  </style>
</head>
<body>
  <div class="dashboard">
    <h1 class="title">Finland</h1>

    <div class="population grid-cell">
        <h2>population: </h2>
        <p>5,536,146</p>
    </div>

    <div class="welcome grid-cell">
      <h2>Welcome</h2>
      <p>Natural Resources, Economic Initiatives, Community Spaces</p>
    </div>

    <div class="gdp grid-cell">
      <h2>GDP</h2>
      <p>257 billion</p>
    </div>

    <div class="code grid-cell">
      <h2>Calling Code</h2>
      <p>+ 358</p>
    </div>

    <div class="govt grid-cell">
      <h2>Government</h2>
      <p>Unitary parliamentary republic</p>
    </div>

    <div class="news grid-cell">
      <h2>News</h2>
      <label for="name">Name:</label>
      <input id="name" type="text" placeholder="name"/>
      <label for="email">Email:</label>
      <input id="email" type="email" placeholder="email"/>
      <button>Send</button>
    </div>

  </div>

</body>
</html>
```


text:
# Broker

Brokers function as intermediaries or roots in the HELICS hierarchy
The Broker can be run through the helics_broker or via helics-app

## Command line arguments

```text
helics_broker term <broker args...> will start a broker and open a terminal control window for the broker run help in a terminal for more commands
helics_broker --autorestart <broker args ...> will start a continually regenerating broker there is a 3 second countdown on broker completion to halt the program via ctrl-C
helics_broker <broker args ..> just starts a broker with the given args and waits for it to complete
allowed options:

command line only:
  -? [ --help ]          produce help message
  -v [ --version ]       display a version string
  --config-file arg      specify a configuration file to use

configuration:
  -n [ --name ] arg      name of the broker
  -t [ --type ] arg      type of the broker ("(zmq)", "ipc", "test", "mpi","test", "tcp", "udp")

 Help for Zero MQ Broker:
allowed options:

configuration:
  --interface arg        the local interface to use for the receive ports
  -b [ --broker ] arg    identifier for the broker
  --broker_address arg   location of the broker i.e network address
  --brokername arg       the name of the broker
  --local                use local interface(default)
  --ipv4                 use external ipv4 addresses
  --ipv6                 use external ipv6 addresses
  --external             use all external interfaces
  --brokerport arg       port number for the broker priority port
  --localport arg        port number for the local receive port
  --port arg             port number for the broker's port
  --portstart arg        starting port for automatic port definitions

 Help for Interprocess Broker:
allowed options:

configuration:
  --queueloc arg         the named location of the shared queue
  -b [ --broker ] arg    identifier for the broker
  --broker_address arg   location of the broker i.e network address
  --brokerinit arg       the initialization string for the broker

 Help for Test Broker:
allowed options:

configuration:
  --brokername arg       identifier for the broker-same as broker
  -b [ --broker ] arg    identifier for the broker
  --broker_address arg   location of the broker i.e network address
  --brokerinit arg       the initialization string for the broker

 Help for TCP Broker:
allowed options:

configuration:
  --interface arg        the local interface to use for the receive ports
  -b [ --broker ] arg    identifier for the broker
  --broker_address arg   location of the broker i.e network address
  --brokername arg       the name of the broker
  --local                use local interface(default)
  --ipv4                 use external ipv4 addresses
  --ipv6                 use external ipv6 addresses
  --external             use all external interfaces
  --brokerport arg       port number for the broker priority port
  --localport arg        port number for the local receive port
  --port arg             port number for the broker's port
  --portstart arg        starting port for automatic port definitions

 Help for UDP Broker:
allowed options:

configuration:
  --interface arg        the local interface to use for the receive ports
  -b [ --broker ] arg    identifier for the broker
  --broker_address arg   location of the broker i.e network address
  --brokername arg       the name of the broker
  --local                use local interface(default)
  --ipv4                 use external ipv4 addresses
  --ipv6                 use external ipv6 addresses
  --external             use all external interfaces
  --brokerport arg       port number for the broker priority port
  --localport arg        port number for the local receive port
  --port arg             port number for the broker's port
  --portstart arg        starting port for automatic port definitions

Broker Specific options:

configuration:
  --root                 specify whether the broker is a root

configuration:
  -n [ --name ] arg      name of the broker/core
  --federates arg        the minimum number of federates that will be
                         connecting
  --minfed arg           the minimum number of federates that will be
                         connecting
  --maxiter arg          maximum number of iterations
  --logfile arg          the file to log message to
  --loglevel arg         the level which to log the higher this is set to the
                         more gets logs (-1) for no logging
  --fileloglevel arg     the level at which messages get sent to the file
  --consoleloglevel arg  the level at which message get sent to the console
  --minbrokers arg       the minimum number of core/brokers that need to be
                         connected (ignored in cores)
  --identifier arg       name of the core/broker
  --tick arg             number of milliseconds per tick counter if there is no
                         broker communication for 2 ticks then secondary actions
                         are taken (can also be entered as a time like '10s' or '45ms')
  --dumplog              capture a record of all messages and dump a complete log to file or console on termination
  --terminate_on_error   Specify that the co-simulation should terminate if any error occurs
  --timeout arg          milliseconds to wait for a broker connection (can also
                         be entered as a time like '10s' or '45ms')

  --error_timeout arg    milliseconds to wait before disconnecting after an error
                         (can also be entered as a time like '10s' or '45ms')

```

If the Broker is started with `term` as the first option, a terminal is opened for user entry of commands all command line arguments following term are passed to the broker.

```bash
starting broker
helics>>help
`quit` -> close the terminal application and wait for broker to finish
`terminate` -> force the broker to stop
`terminate*` -> force the broker to stop and exit application
`help`,`?` -> this help display
`restart` -> restart a completed broker
`status` -> will display the current status of the broker
`info` -> will display info about the broker
`force restart` -> will force terminate a broker and restart it
`query` <queryString> -> will query a broker for <queryString>
`query` <queryTarget> <queryString> -> will query <queryTarget> for <queryString>
helics>>
```

`status` will print out current status of the brokers including counts of federates, brokers, and handles

```bash
helics>>status
Broker (643204-ibrVd-14EWH-unKfh-hExUP) is connected and is accepting new federates
{"brokers":0,
"federates":0,
"handles":0}
helics>>
```

info prints out name, connection status, and connection information

```bash
helics>>info
Broker (643204-ibrVd-14EWH-unKfh-hExUP) is connected and is accepting new federates
address=tcp://<IP_ADDRESS>:23404
```

The `query` command allows any query to be executed from the command line, `query counts` displays the same count numbers as `status`.

Other available queries are described in [Queries](../../user-guide/advanced_topics/queries.md).

various restart options are also available, `terminate`, `restart`, `force restart`. And finally `quit` will exit the terminal and wait for the broker to complete. enter `terminate` before quit or `terminate*` to terminate and quit.

repository: GMLC-TDC/HELICS

repo_name: GMLC-TDC/HELICS


text:
## Resubmission
This is a resubmission. In this version I have:

* Change codecov URL to https://app.codecov.io/gh/JorgeDelro/MFO?branch=master.
* References have been added to the DESCRIPTION file.
* TRUE and FALSE were written instead of T and F.
* \value have been added to .Rd files.
* functions do not write by default  in the user's home filespace. tempdir() is used.
* User's working directory is saved and setting after the example is executed in a temporary directory

## Test environments
* local R installation, R 4.0.3
* ubuntu 16.04 (on travis-ci), R 4.0.3
* win-builder (devel)
* windows-x86_64-devel (r-devel)
* ubuntu-gcc-release (r-release)
* fedora-clang-devel (r-devel)

## R CMD check results

0 errors | 0 warnings | 1 note

* New submission.

repository: JorgeDelro/MFO

repo_name: JorgeDelro/MFO


text:
# Rangeable

[![npm](https://img.shields.io/npm/dt/rangeable.svg)](https://www.npmjs.com/package/rangeable)
[![npm version](https://badge.fury.io/js/rangeable.svg)](https://badge.fury.io/js/rangeable)
[![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/Mobius1/Rangeable/blob/master/LICENSE)
[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/Mobius1/Rangeable.svg)](http://isitmaintained.com/project/Mobius1/Rangeable "Average time to resolve an issue")
[![Percentage of issues still open](http://isitmaintained.com/badge/open/Mobius1/Rangeable.svg)](http://isitmaintained.com/project/Mobius1/Rangeable "Percentage of issues still open")
![](http://img.badgesize.io/Mobius1/Rangeable/master/dist/rangeable.min.js) ![](http://img.badgesize.io/Mobius1/Rangeable/master/dist/rangeable.min.js?compression=gzip&label=gzipped)

A dependency-free, responsive and touch-enabled vanilla javascript range slider to make `<input type="range">` elements prettier and more configurable.

- [x] No dependencies
- [x] 3kb gzipped
- [x] Touch enabled
- [x] Responsive
- [x] Single or double range layouts.
- [x] Horizontal and vertical orientations.
- [x] Fully stylable to fit your app.

![Rangeable](/docs/rangeable.png?raw=true "Rangeable")

** Rangeable is still in active development and therefore the API is in constant flux until `v1.0.0`. Check back regularly for any changes and make sure you have the latest version installed.**

## [Live Demos](https://codepen.io/collection/AEWWkz/)

---

## Install

### npm
```
npm install rangeable --save
```

---

### Browser

Grab the files from one of the CDNs and include them in your page:

```
<EMAIL_ADDRESS><EMAIL_ADDRESS>```

You can replace `latest` with the required release number if needed.

---

### Default

Create a new instance:

```javascript
const rangeable = new Rangeable(input, {
    type: "single",
    tooltips: "always",
    min: 0,
    max: 100,
    step: 1,
    value: 50,
    vertical: false,
    controls: undefined,
    onInit: function() {
        // do something when the instance has loaded
    },
    onStart: function() {
        // do something on mousedown/touchstart
    },
    onChange: function() {
        // do something when the value changes
    },
    onEnd: function() {
        // do something on mouseup/touchend
    }
});
```

You can pass either a reference to the input or a CSS3 selector string:

```javascript
const myRangeInput = document.getElementById('myRangeInput');
const rangeable = new Rangeable(myRangeInput);

// or

const rangeable = new Rangeable('#myRangeInput');
```

## Options

[See Options](https://github.com/Mobius1/Rangeable/wiki/Options)

---

## Public Methods

[See Public Methods](https://github.com/Mobius1/Rangeable/wiki/Public-Methods)

---

Copyright © 2018 Karl Saunders | BSD & MIT license


text:
# Capistrano::Bearychat

Send notifications to [Bearychat](https://bearychat.com) about [Capistrano v3](http://www.capistranorb.com) deployments. Inspired by [slackistrano](https://github.com/supremegolf/slackistrano).

## Requirements

- Capistrano >= 3.1.0
- Ruby >= 2.0
- A Bearychat account

## Installation

Add this line to your application's Gemfile:

    gem "capistrano",  "~> 3.1"
    gem "capistrano-bearychat", require: false

And then execute:

    $ bundle

## Configuration

To notify a channel in Bearychat when you deploy, Using *Incoming WebHooks* integration, offering more options but requires one of the five free integrations.

You need to enable the integration inside Bearychat and get the incoming webhook url that will be needed later.

Require the library in your application's Capfile:

    require 'capistrano/bearychat'

You need to set your webhook url in your application's config/deploy.rb:

    set :bearychat_webhook, "https://hook.bearychat.com/XXXX/XXX/XXXXX"

Optionally, override the other settings:

    set :bearychat_channel,          -> { '#general' }
    set :bearychat_using_markdown,   ->{ false } # Set to true to treat text as markdown.
    set :bearychat_channel_starting, -> { nil } # Channel to post to. Optional. Defaults to :bearychat_channel.
    set :bearychat_channel_finished, -> { nil } # Channel to post to. Optional. Defaults to :bearychat_channel.
    set :bearychat_channel_failed,   -> { nil } # Channel to post to. Optional. Defaults to :bearychat_channel.
    set :bearychat_run_starting,     -> { true }
    set :bearychat_run_finished,     -> { true }
    set :bearychat_run_failed,       -> { true }
    set :bearychat_msg_starting,     -> { "#{ENV['USER'] || ENV['USERNAME']} has started deploying branch #{fetch :branch} of #{fetch :application} to #{fetch :rails_env, 'production'}" }
    set :bearychat_msg_finished,     -> { "#{ENV['USER'] || ENV['USERNAME']} has finished deploying branch #{fetch :branch} of #{fetch :application} to #{fetch :rails_env, 'production'}" }
    set :bearychat_msg_failed,       -> { "#{ENV['USER'] || ENV['USERNAME']} failed to deploy branch #{fetch :branch} of #{fetch :application} to #{fetch :rails_env, 'production'}" }

**Note**: You may wish to disable one of the notifications if another service (ex:
Honeybadger) also displays a deploy notification.

Test your setup by running:

    $ cap production bearychat:deploy:starting
    $ cap production bearychat:deploy:finished
    $ cap production bearychat:deploy:failed

## Usage

Deploy your application like normal and you should see messages in the channel
you specified.

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: kaichen/capistrano-bearychat

repo_name: kaichen/capistrano-bearychat


text:
# Show ACPI Tables

Shows the system ACPI tables related to persistent memory modules.

```
ipmctl show [OPTIONS] -system (NFIT|PCAT|PMTT)
```

## **Targets**

* `system (NFIT|PCAT|PMTT)`: The system ACPI table(s) to display. By default both the NFIT and PCAT tables are displayed. One of:
  * "NFIT": The NVDIMM Firmware Interface Table
  * "PCAT": The Platform Capabilities Table
  *   "PMTT": The Platform Memory Topology Table

      Refer to the ACPI specification for detailed information about the ACPI tables.

## **Examples**

Show the ACPI NFIT

```
$ sudo ipmctl show -system NFIT
```

## **Return Data**

Returns the formatted data from the requested ACPI tables and their sub-tables. Refer to the ACPI specification for detailed information about the format of the ACPI tables.

> Note: All data is presented in ACPI little endian format.

repository: pmem/docs

repo_name: pmem/docs


text:
# Deprecated

I've switched to the [cthulhoo/ttrss-fpm-pgsql-static](https://hub.docker.com/r/cthulhoo/ttrss-fpm-pgsql-static) image, and hence will not be maintaining this image going forward. Refer to the [docker-compose](https://git.tt-rss.org/fox/ttrss-docker-compose/src/branch/static-dockerhub/README.md) example for further details.

# Original README below

# docker-ttrss

[![GitHub Issues](https://img.shields.io/github/issues/acch/docker-ttrss.svg)](https://github.com/acch/docker-ttrss/issues) [![GitHub Stars](https://img.shields.io/github/stars/acch/docker-ttrss.svg?label=github%20%E2%98%85)](https://github.com/acch/docker-ttrss/) [![Docker Pulls](https://img.shields.io/docker/pulls/acch/ttrss.svg)](https://hub.docker.com/r/acch/ttrss/) [![License](https://img.shields.io/github/license/acch/docker-ttrss.svg)](LICENSE)

[Tiny Tiny RSS](https://tt-rss.org/) Docker image. Includes [SMTP mailer plugin](https://git.tt-rss.org/fox/ttrss-mailer-smtp) for Email notifications.

## Usage

Tiny Tiny RSS requires a database to run. The recommended way of starting both containers is with [Docker-Compose](https://docs.docker.com/compose/compose-file):

    version: '3'

    services:
      db:
        image: mariadb
        container_name: ttrss_db
        volumes:
          - db:/var/lib/mysql
        environment:
          - MYSQL_RANDOM_ROOT_PASSWORD=yes
        env_file:
          - db.env
        restart: always

      app:
        image: acch/ttrss
        container_name: ttrss_app
        environment:
          - MYSQL_HOST=db
          - VIRTUAL_HOST=ttrss.mydomain.com
          - SMTP_SERVER=mail.mydomain.com:25
          -<EMAIL_ADDRESS>        env_file:
          - db.env
        depends_on:
          - db
        restart: always

    volumes:
      db:
        driver: local

The file `db.env` contains (secret) database credentials:

    MYSQL_DATABASE=ttrss
    MYSQL_USER=ttrss
    MYSQL_PASSWORD=<mysecretpassword>

## Getting Started

When running Tiny Tiny RSS for the first time one needs to initialize the database. Do so by completing the installation wizard by pointing a web browser towards: `http://ttrss.mydomain.com/install/`.

See `https://git.tt-rss.org/fox/tt-rss/wiki/InstallationNotes` for details. Note that the configuration file `config.php` is automatically generated when starting a container from this image, based on environment variables.

## Environment Variables

The following environment variables are used to generate the `config.php` configuration file:

| Docker Environment Variable | TT-RSS Configuration Option |
| --------------------------- | --------------------------- |
| MYSQL_HOST                  | `DB_HOST`                   |
| MYSQL_USER                  | `DB_USER`                   |
| MYSQL_DATABASE              | `DB_NAME`                   |
| MYSQL_PASS                  | `DB_PASS`                   |
| VIRTUAL_HOST                | `SELF_URL_PATH`             |
| SMTP_SERVER                 | `SMTP_SERVER`               |
| SMTP_FROM_NAME              | `SMTP_FROM_NAME`            |
| SMTP_FROM_ADDRESS           | `SMTP_FROM_ADDRESS`         |

Refer to [config.php](https://git.tt-rss.org/fox/tt-rss/src/master/config.php-dist) for a detailed explanation of these configuration options.

## Copyright

Copyright 2019 Achim Christ, released under the [MIT license](LICENSE)

repository: acch/docker-ttrss

repo_name: acch/docker-ttrss


text:
Hello VSCode + MinGW
===

A sample project.

Requirements:
* Visual Studio Code
* VSCode C/C++ VSCode plugin
* MinGW32 installed in `c:\mingw`
    * in case of different path edit `.vscode/*.json` files

repository: jborza/hello-vscode-mingw

repo_name: jborza/hello-vscode-mingw


text:
---
layout:     post
title:      "Problem: Maximum Frequency Stack"
date:       2015-02-18 00:00:00
author:     "Marcy"
header-img: "img/post-bg-2015.jpg"
catalog: true
category: algnote
algnote-tags:
    - Coding Interview
    - Coding Practice
    - Algorithms and Data Structures
    - Stack
    - Hard
---

## Question

Implement FreqStack, a class which simulates the operation of a stack-like data structure.

FreqStack has two functions:

- push(int x), which pushes an integer x onto the stack.
- pop(), which removes and returns the most frequent element in the stack.
- If there is a tie for most frequent element, the element closest to the top of the stack is removed and returned

## Solution
TODO

#### Code
```java
class FreqStack {
    int maxFreq = 0;
    Map<Integer, Stack<Integer>> freqStackMap;
    Map<Integer, Integer> valueFreqMap;

    public FreqStack() {
        valueFreqMap = new HashMap<>();
        freqStackMap = new HashMap<>();
    }

    public void push(int x) {
        int freq = valueFreqMap.getOrDefault(x, 0)+1;
        valueFreqMap.put(x, freq);
        if(freq > maxFreq) maxFreq = freq;
        Stack<Integer> stack;
        if(!freqStackMap.containsKey(freq)) {
            stack = new Stack<>();
            freqStackMap.put(freq, stack);
        }
        else {
            stack = freqStackMap.get(freq);
        }

        stack.push(x);
    }

    public int pop() {
        Stack<Integer> stack = freqStackMap.get(maxFreq);
        int x = stack.pop();
        int freq = valueFreqMap.get(x);
        if(freq == 1) valueFreqMap.remove(x);
        else valueFreqMap.put(x, freq-1);

        if(stack.isEmpty()) maxFreq--;

        return x;
    }
}

/**
 * Your FreqStack object will be instantiated and called as such:
 * FreqStack obj = new FreqStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 */
```

## Performance
O(1) for both push and pop.

path: /_posts/Algorithms and Data Structures/problems/2015-09-01-Stack-and-Queue/2015-09-21-maximum-frequency-stack.markdown

extension: markdown


text:
# TowerDefense (Unity StarterKit)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7741254.svg)](https://doi.org/10.5281/zenodo.7741254)
  [![GitHub all releases](https://img.shields.io/github/downloads/frangam/towerdefense/total)](https://github.com/frangam/TowerDefense/releases/download/1.0/TowerDefenseTest_Web.zip)

A scalable Tower Defense game framework made with [Unity3D] in C# with a basic AI avoids turrets.
That is like a starter kit for creating your own Tower Defense game.

All the code is commented to understand how it works and is well structured in order to be readable.

## Download last release
Support us downloading our last release
- Click on this button to download [![GitHub all releases](https://img.shields.io/github/downloads/frangam/towerdefense/total)](https://github.com/frangam/TowerDefense/releases/download/1.0/TowerDefenseTest_Web.zip)
- We also appreciate your support downloading it on ZENODO site: [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7741254.svg)](https://doi.org/10.5281/zenodo.7741254)

# Game Scene
The Game scene is called "Demo" and it is localed in “Scenes” folder.

# Controls
- W, A, S, D: move camera.
- Right Mouse: rotate camera.
- Scroll Mouse: zoom camera.
- ESC: reset view.

# Screenshots

# Grid Generation
There are too many ways to implement this. We decided to do it by instantiating prefabs that represent each cell with a "Quad" component
attached. We chose this because it is simple and does not require a higher performance. However, the best way could be to apply the voxel
technique, but it takes a very more time to implement and for our purpose the chosen form is valid.

We have registered all instantiated cells in an array to access whenever I want to do something with them.

## GridGenerator
We apply singleton pattern to having a unique instance of this manager.
In the demo scene we find “GridGenerator” game object handles this process. We can modify in the inspector some attributes I present in
the following table:

| Attribute | Description |
| :---         |     :--- |
| Width   | This is the width of the grid.    |
| Height    | This is the height of the grid.     |
|Cells Pbs|This is an array with all of the different cells we have (prefabs).|
|Enemies Spawner Coords|This is an array with all of the cells coordinates when we want to enemy forces spawn.|
|Crystals Coords|This is an array with all of the cells coordinates when we want to there are crystals.|

We have a personalized exception (“RepeatedCoordsException”) to control enemy and crystal cells whose coordinates are not equal.

## Cells
Every tile prefab has two materials, one for render a grid around it and other one for the own color of cell.
We have four types of cells:
1. Normal: a basic cell where we can put turrets.
2. Bound: represents a bound of the grid and we cannot put any turret on this.
3. Enemy: where enemies are spawned.
4. Crystal: where crystals are located.

We can see the class hierarchy in the following UML diagram:

We have considered a cell like a node that has two coordinates to locate it easily in the grid array of GridGenerator.
Also, we can know if it is walkable, that is, an enemy can walk through it. This is useful for the Pathfinding implemented,
the same way it is important to know neighbors nodes so we have an array with them.

We use delegates and events in Cell class to notify when we put a turret because enemies need to recalculate their path to continue
moving and skip this cell.

We use delegates in Crystal Cell to notify enemies when a crystal cell has no more crystals and they recalculate their path again
choosing a new target crystal cell.

# Turrets
This is the turrets class hierarchy:

A Turret game object has a sphere collider component that is fired when an enemy collides with it, then it is added to the turret’s target.
Enemies that are in range are put in a target’s pool sorted by natural order criterion of Enemy class. Also, turrets has a price to buy
them.

Shot method is called in the Unity’s Update every frame. To control that each type of turret shot with an specific rate it has “shotRate”
parameter. In Laser Turret case, this attribute is set to zero to apply damage to target enemy in every frame. Cannon Turret shots bullets
with a specific delay that if they impact to the target, then they apply the damage and, if not, bullets are destroyed when are out of the
turret’s range.

# Units
We present class diagram of units handling:

Enemy class implements “CompareTo” method from System.IComparable to establish the natural order criterion for an enemy, that is, which
enemy is closer to catch its crystal. This is useful when a turret add target’s enemies to its pool attribute, because it sorts its list
with this criterion to shot the nearest enemy that gets its crystal.

## Waves
We have implemented a Waves system to spawn units:

## Pathfinding with BFS Algorithm
We have used [BFS algorithm](http://en.wikipedia.org/wiki/Breadth-first_search#Pseudocode) pseudo code to implement pathfinding.

I register every previous non-visited node to go from it to its neighbour, so when finish BFS in target node, I have to retrieve them
inverted. At the finish, I revert the final path to be prepared in the correct order just to enemy starts moving.

 [Unity3D]: <https://unity3d.com>

repository: frangam/TowerDefense

repo_name: frangam/TowerDefense


text:
---
layout: text/textblock
---

Choose a method and outcome that will help you to focus on the tasks people are trying to complete. Your skill will be to know where and when to apply the right method to the right context.

Every project and stakeholder group is different and you will need to achieve different outcomes and agendas. Think about the intent and the outcome to find the right set of methods for that context.

### [2]Journey maps

Create a journey map after your user research sessions. You will get a broad view of the whole user’s experience and how your content could fit into that.

### [2]User profiles
Create a user profile based on your user research. You will be building up a profile of your users’ attitudes and behaviours.

### [2]User and job stories
Write user or job stories that describe why and how a user interacts with your service or information. Your stories will help to build out the foundations for creating content.

### [2]Top tasks
Use this activity to agree and focus on the top tasks a user is trying to complete on your service.

repository: govau/service-manual

gha_language: JavaScript

repo_name: govau/service-manual


text:
## Architecture

Assume that you want me to design api for booking service with the flow:

1. Customer calling the Gateway API /gateway/booking/:tripId

2.a Gateway call Booking Service API /booking
2.b Gateway call Billing Service API /billing

3.a If 2.a and 2.b both success, return success
3.b If one of 2.a or 2.b fail, return fail

To keep the simplicity and scalablity, I assume that `billing` and `booking` are two REST microservices, and will ignore all the authentication/authorization in this case.
To archive Atomic transaction, I will design these follow the TCC (Try, Cancel/Confirm) concept.

### Billing Service

The billing service is responsible for calling payment service/reduce.
Billing service is a participant in the TCC.
Require: Default timeout to cancel
         Confirm is idempotent (PUT), and will remove the timeout

This is a normal REST service so it will follow the usual REST design.

GET /billing/:id
  // Get a billing
POST /billing
  // Create a billing
  // The timeout (expiredAt is auto-generated, 1 minutes in the future)
PUT /billing/:id
  // Update billing
DELETE /billing/:id
  // Delete the billing

### Booking Service
Booking service is a participant in the TCC.
Require: Default timeout to cancel
         Confirm is idempotent (PUT), and will remove the timeout

Identical with billing

GET /booking/:id
  // Get a booking
POST /booking
  // Create a booking
PUT /booking/:id
  // Update booking
DELETE /booking/:id
  // Delete the booking

### Gateway service
Gateway is a puppet master, controlling billing and booking.

POST /gateway/booking
  // Create booking by combine booking and billing service.
The timeof between both service assure that, before confirm, both will fail eventually.
After confirm, both will success.

If confirmation fail, we going to repeat the confirmation, because all API calls in confirmation are idempotent.

The recovery procedure is differently treated, and will act independent with gateway.

### Sample composition

The following shows the success composition of two services.

1. POST /gateway/booking/trip_A

2.a POST /booking
  Data: tripId=trip_A

  RES: 200
       bookingId=trip_A_bookingId
2.b POST /billing
  Data: tripId=trip_A

  RES: 200
       billingId = trip_a_billingId

// Confirm
3.a PUT /booking/trip_A_bookingId
  RES: 204
3.b PUT /billing/trip_a_billingId
  RES: 204

The following shows a failed composition of two services.

1. POST /gateway/booking/trip_A

2.a POST /booking
  Data: tripId=trip_A

  RES: 200
       bookingId=trip_A_bookingId
2.b POST /billing
  Data: tripId=trip_A

  RES: 402
  (Can not bill user, out of cash)

// Cancel
3.a DELETE /booking/trip_A_bookingId
  RES: 204
3.b DELETE /billing/trip_a_billingId
  RES: 204


text:
## Comparison Operators\#Less than or equal operator

### Summary

JavaScript has both strict and type--converting comparisons. A strict comparison (e.g., `===`) is only true if the operands are of the same type. The more commonly used abstract comparison (e.g. `==`) converts the operands to the same Type before making the comparison. For relational abstract comparisons (e.g., `<=`), the operands are first converted to primitives, then to the same type, before comparison.

Strings are compared based on standard lexicographical ordering, using Unicode values.

Features of comparisons:

* Two strings are strictly equal when they have the same sequence of characters, same length, and same characters in corresponding positions.
* Two numbers are strictly equal when they are numerically equal (have the same number value). [NaN][0] is not equal to anything, including NaN. Positive and negative zeros are equal to one another.
* Two Boolean operands are strictly equal if both are `true` or both are `false`.
* Two distinct objects are never equal for either strict or abstract comparisons.
* An expression comparing Objects is only true if the operands reference the same Object.
* Null and Undefined Types are strictly equal to themselves and abstractly equal to each other.

### Equality operators

### Equality (==)

The equality operator converts the operands if they are **not of the same type**, then applies strict comparison. If **both operands are objects**, then JavaScript compares internal references which are equal when operands refer to the same object in memory.

#### Syntax

    x == y

#### Examples

     1   ==  1     // true
    "1"  ==  1     // true
     1   == '1'    // true
     0   == false  // true

### Inequality (!=)

The inequality operator returns true if the operands are not equal. If the two operands are **not of the same type**, JavaScript attempts to convert the operands to an appropriate type for the comparison. If **both operands are objects**, then JavaScript compares internal references which are not equal when operands refer to different objects in memory.

#### Syntax

    x != y

#### Examples

    1 !=   2     // true
    1 !=  "1"    // false
    1 !=  '1'    // false
    1 !=  true   // false
    0 !=  false  // false

### Identity / strict equality (===)

The identity operator returns true if the operands are strictly equal (see above) **with no type conversion**.

#### Syntax

    x === y

#### Examples

    3 === 3   // true
    3 === '3' // false

### Non-identity / strict not equal (!==)

The non-identity operator returns true if the operands **are not equal and/or not of the same type**.

#### Syntax

    x !== y

#### Examples

    3 !== '3' // true
    4 !== 3   // true

### Relational operators

### Greater than operator (\>)

The greater than operator returns true if the left operand is greater than the right operand.

#### Syntax

    x > y

#### Examples

    4 > 3 // true

### Greater than or equal operator (\>=)

The greater than or equal operator returns true if the left operand is greater than or equal to the right operand.

#### Syntax

     x >= y

#### Examples

    4 >= 3 // true
    3 >= 3 // true

### Less than operator (<)

The less than operator returns true if the left operand is less than the right operand.

#### Syntax

     x < y

#### Examples

    3 < 4 // true

### Less than or equal operator (<=)

The less than or equal operator returns true if the left operand is less than or equal to the right operand.

#### Syntax

     x <= y

#### Examples

    3 <= 4 // true

### Using the Equality Operators

The standard equality operators (`==` and `!=`) use the [Abstract Equality Comparison Algorithm][1] to compare two operands. If the operands are of different Types, it will attempt to convert them to the same Type before making the comparison, e.g., in the expression `5 == '5'`, the string on the right is converted to Number before the comparison is made.

The strict equality operators (`===` and `!==`) use the Strict Equality Comparison Algorithm and are intended for performing equality comparisons on operands of the same Type. If the operands are of different Types, the result is always `false` so `5 !== '5'`.

Use strict equality operators if the operands must be of a specific Type as well as value or if the exact Type of the operands is important. Otherwise, use the standard equality operators, which allow you to compare the identity of two operands even if they are not of the same Type.

When Type conversion is involved in the comparison (i.e., non--strict comparison), JavaScript converts Type String, Number, Boolean, or Object operands as follows:

* When comparing a number and a string, the string is converted to a number value. JavaScript attempts to convert the string numeric literal to a `Number` type value. First, a mathematical value is derived from the string numeric literal. Next, this value is rounded to nearest `Number` type value.
* If one of the operands is `Boolean`, the Boolean operand is converted to 1 if it is `true` and +0 if it is `false`.
* If an object is compared with a number or string, JavaScript attempts to return the default value for the object. Operators attempt to convert the object to a primitive value, a `String` or `Number` value, using the `valueOf` and `toString` methods of the objects. If this attempt to convert the object fails, a runtime error is generated.
* Note that an object is converted into a primitive if, and only if, its comparand is a primitive. If both operands are objects, they're compared as objects, and the equality test is true only if both refer the same object.

**Note:** String Objects are Type Object, not String! String objects are rarely used, so the following results might be surprising:

    // true as both operands are Type String (i.e. string primitives):
    'foo' === 'foo'

    var a = new String('foo');
    var b = new String('foo');

    // false as a and b are Type Object and reference different objects
    a == b

    // false as a and b are Type Object and reference different objects
    a === b

    // true as a and 'foo' are of different type and, the Object (a)
    // is converted to String 'foo' before comparison
    a == 'foo'

[0]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NaN "NaN"
[1]: http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3


text:
# Salt-channel-c

About
-----

C implementation of [Salt Channel](https://github.com/assaabloy-ppi/salt-channel). *Salt Channel is "Powered by Curve25519"*

**License:** MIT

## Development
The salt-channel-c is mainly developed using the following tools:
* Ubuntu
* gcc
* CMake
* CMocka
* lcov

### To test the implementation or contribute with development:
1. Install tools
```
$ apt-get install cmake libcmocka-dev lcov
```
2. Build
```
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make test
```

### Importing to eclipse
Eclipse can be used for development and debugging. Assumed that this repository is cloned to your home folder and that the eclipse workspace is located in **~/workspace** the setup could be done similar to this:

1. Clone this repository and initiate the eclipse workspace:

```
$cd ~/
$ git clone https://github.com/assaabloy-ppi/salt-channel-c
$ mkdir -p ~/workspace/salt-channel-c
$ cmake -G "Eclipse CDT4 - Unix Makefiles" ~/salt-channel-c
```

2. In eclipse: **File > Import > General > Existing Projects into Workspace**
3. Check **Select root directory** and chose ~/workspace/salt-channel-c, make sure **Copy projects into workspace** is NOT checked.
4. Press **Finish**.

Note: If any cmake configuration files is modified you need to repeat **step 1**.

### A simple example
An echo salt-channel host is provided. If a message that is sent to the host starts with the byte **0x01** the host will echo the same message to the client.

**Host-side:**
```
$ ./examples/host_echo
Socket created
bind done
Waiting for incoming connections...
Connection accepted
Waiting for client to disconnect.
Waiting for incoming connections...
Salt handshake succeeded.
```
**Client-side:**
```
$ ./examples/client_echo
Connection to <IP_ADDRESS>
Connected successfully - Please enter string
Salt handshake succeeded.
Enter message: Hello
client: Hello
host: Hello
Enter message:

```

## Implementation details

Salt-channel-c is an implementation of the salt-channel over a serial stream. I.e., the expected input data format and the output data format follows the following structure:

    **** Stream message structure ****

    4   Size.
        Four size bytes in Littleendian byte order. E.g.:
        Size = 4: sizeBytes[4] = { 0x04, 0x00, 0x00, 0x00 }

### Goals

* **Non-blocking:**
The salt-channel implementation should be non-blocking. I.e., the implementation must be able to run on a system without threads. However, the user of the implementation may make it blocking depending on user injected I/O implementation. The state of each salt-channel process must be either SUCCESS, PENDING or error.

* **No dynamic memory allocation:**
The salt-channel-c implementation must work on systems with no heap. However, it's up to the user of the implementation to decide whether to use dynamic memory allocation since all used buffers are injected.

* **Slow I/O:**
Do cryptographic computations during I/O. If the I/O is slow, some of the crypthographic computations can be calculated while waiting for I/O:

    * Client sends the ehpemeral public encryption key in message M1.
    * Host received the client key and immediately sends the host key in message M2.
    * While I/O, calculate the ephemeral key. Immediately after this, start calculating the signature used for M3.
    * Client received the host key and immediately starts calculating this. This can be done while the M3 message is received from the host. Directly after this, the client starts calculating the signature used for M4.
    * Client receives M3 and the host signature. If the signature is valid and the host can be authenticated, the clients send the M4 message containing the clients signature.

### General message structure
Except for message *M1* each message follows this structure:

    **** Salt-channel message structure ****
    2   Header.

    N   Payload.

### TweetNaCl API
The TweetNaCl library is a subset of the NaCl library and the crypto API used for this implementation is available at https://nacl.cr.yp.to/.

**Encryption:**
The encryption API crypto_box_afternm requires the first 32 (crypto_secretbox_ZEROBYTES) bytes to be zero (0x00) padded. After encryption the first 16 (crypto_secretbox_BOXZEROBYTES) will be zero (0x00):
```
--> Clear text data must be zero padded:
    clearText[N] = { zeroPadded[32] , clearText[N-32] }
--> Encrypt:
    encryptedAndAuthenticated = { zeroPadded[16] , cipher[N-16] }
```
In order to minimize send data over slow I/O channels the 16 zero padded bytes are neglected.

**Decryption:**
The decryption API crypto_box_open_afternm requires the first 16 bytes to be zero (0x00) padded. After decryption the first 32 bytes will be zero.
```
--> Cipher data must be zero padded:
    encryptedAndAuthenticated[N] = { zeroPadded[16] , cipher[N-16] }
--> Decrypt:
    clearText[N-32] = { zeroPadded[32] , clearText[N-32] }
```

Both the crypto_box_afternm and the crypto_box_open_afternm methods allows to perform the cryptographic operations directly on the buffers.

**Hashing:**
sha512 is used for hashing and the size of a hash is 64 bytes. If the message to hash is larger than 64 bytes, the API allows for putting the hash where the original message was. I.e.: We don't need a specific storage for the hash, if we dont want to save the original message.

**Signing:**
The TweetNaCl API doesn't allow to only generate a signature (64 bytes) or verify a message with the signature separated from the message. Further, the API requires a seperate buffer to put the signed and unsigned message in.

### Server handshaking procedure

TODO: Write or refer to  code.

### Client handshaking procedure

TODO: Write or refer to code.

repository: mjurczak/salt-channel-c

repo_name: mjurczak/salt-channel-c


text:
# April 2021 Update Notes "Using React Hooks"

## General Updates to Course

* Updated to React 17.0.2
* Updated to Next.js version 10.0.9 (including API Routing)
* Updated eslint file
* Removed all references to json-server (replaced by NextJS API Routes)
* Removed all references to react-toastify and associated code
* Removed the package bootstrap and just include bootstrap.css now from /public/static folder

## Module 2

* Small changes and fixes

## Module 3

* Clips 3 and 4 completely re-written.  All the code for the demo app is now developed.  Removed overview and replaced with coding details.

## Module 4

No changes

## Module 5

Clips 7 through 13 are all new. They start out with implementing the REST server using NextJS API routes. Then, after
all the coding and examples are upgrade to REST, the code is upgrade to handle server-side rendering.  Following that, the code is
updated to Incremental Static Regeneration, which means static pages are generated by the node server in the background when there are
REST backend changes, but all pages are rendered to user are 100% static.

## Module 6

Clip 8 was added to solve a bug where the saturday/sunday checkboxes did not cause the images to recalculate whether they are in view or not (causing colorization to be wrong until a scroll event happens).


text:
# Blotify
Blotify is an an iOS 11 / Swift 4 based music player app that searches Spotify for music to play.

![](art/screenshot/blotify-00.png?raw=true)

The app uses [Alamofire](https://github.com/Alamofire/Alamofire) for Networking and the eternally in Beta [Spotify iOS SDK](https://developer.spotify.com/technologies/spotify-ios-sdk/) for Authentication.

### Contributing
See [CONTRIBUTING](CONTRIBUTING.md).

### Licensing
Blotify is licensed under [the MIT License](LICENSE).

### Support or Contact
Visit [ddApps.co](http://ddapps.co) to see more.

repository: duliodenis/blotify

repo_name: duliodenis/blotify


text:
Hydra
=====

This project builds and runs Hydra docker container.

Running with SSL and opaque tokens
----------------------------------

By default Hydra issues non-JWT tokens that can't be locally introspected.

From `docker` directory run:

    docker-compose -f compose.yml -f hydra/compose.yml up --build

A keystore is pre-generated in `certificates` sub-directory.
There is also a pre-generated CA root certificate, used to sign server certificate, in `../certificates`:

Running with SSL and JWT tokens
-------------------------------

From `docker` directory run:

    docker-compose -f compose.yml -f hydra/compose-with-jwt.yml up --build

A keystore is pre-generated in `certificates` sub-directory.
There is also a pre-generated CA root certificate, used to sign server certificate, in `../certificates`:

Regenerating server certificate
-------------------------------

If you want to regenerate a server keystore run the following:

    cd certificates
    rm *.srl *.crt *.key *.csr
    ./gen-hydra-certs.sh

repository: strimzi/strimzi-kafka-oauth

gha_language: Java

repo_name: strimzi/strimzi-kafka-oauth


text:
# Angular Roadmap

Angular receives a large number of feature requests, both from inside Google and from the broader open-source community. At the same time, our list of projects contains plenty of maintenance tasks, code refactorings, potential performance improvements, and so on. We bring together representatives from developer relations, product management, and engineering to prioritize this list. As new projects come into the queue, we regularly position them based on relative priority to other projects. As work gets done, projects will move up in the queue.

The projects below are not associated with a particular Angular version. We'll release them on completion, and they will be part of a specific version based on our release schedule, following semantic versioning. For example, features are released in the next minor after they are complete, or the next major if they include breaking changes.

## In Progress

### Operation Bye Bye Backlog (aka Operation Byelog)

We are actively investing up to 50% of our engineering capacity on triaging issues and PRs until we have a clear understanding of broader community needs. After that, we'll commit up to 20% of our engineering capacity to keep up with new submissions promptly.

### Support TypeScript 4.0

We're working on adding support for TypeScript 4.0 ahead of its stable release. We always want Angular to stay up-to-date with the latest version of TypeScript so that developers get the best the language has to offer.

### Update our e2e testing strategy

To ensure we provide a future-proof e2e testing strategy, we want to evaluate the state of Protractor, community innovations, e2e best practices, and explore novel opportunities.

### Angular libraries use Ivy

We are investing in the design and development of Ivy library distribution plan, which will include an update of the library package format to use Ivy compilation, unblock the deprecation of the View Engine library format, and [ngcc](guide/glossary#ngcc).

### Evaluate future RxJS changes (v7 and beyond)

We want to ensure Angular developers are taking advantage of the latest capabilities of RxJS and have a smooth transition to the next major releases of the framework. For this purpose, we will explore and document the scope of the changes in v7 and beyond of RxJS and plan an update strategy.

### Angular language service uses Ivy

Today the language service still uses the View Engine compiler and type checking, even for Ivy applications. We want to use the Ivy template parser and improved type checking for the Angular Language service to match application behavior. This migration will also be a step towards unblocking the removal of View Engine, which will simplify Angular, reduce the npm package size, and improve the framework's maintainability.

### Expand component harnesses best practices

Angular CDK introduced the concept of [component test harnesses](https://material.angular.io/cdk/test-harnesses) to Angular in version 9. Test harnesses allow component authors to create supported APIs for testing component interactions. We're continuing to improve this harness infrastructure and clarifying the best practices around using harnesses. We're also working to drive more harness adoption inside of Google.

### Support native [Trusted Types](https://web.dev/trusted-types/) in Angular

In collaboration with Google's security team, we're adding support for the new Trusted Types API. This web platform API will help developers build more secure web applications.

### Integrate [MDC Web](https://material.io/develop/web/) into Angular Material

MDC Web is a library created by Google's Material Design team that provides reusable primitives for building Material Design components. The Angular team is incorporating these primitives into Angular Material. Using MDC Web will align Angular Material more closely with the Material Design specification, expand accessibility, overall improve component quality, and improve our team's velocity.

### Offer Google engineers better integration with Angular and Google's internal server stack

This is an internal project to add support for Angular front-ends to Google's internal integrated server stack.

### Angular versioning & branching

We want to consolidate release management tooling between Angular's multiple GitHub repositories ([angular/angular](https://github.com/angular/angular), [angular/angular-cli](https://github.com/angular/angular-cli), and [angular/components](https://github.com/angular/components)). This effort will allow us to reuse infrastructure, unify and simplify processes, and improve our release process's reliability.

## Future

### Refresh introductory documentation

We will redefine the user learning journeys and refresh the introductory documentation. We will clearly state the benefits of Angular, how to explore its capabilities, and provide guidance so developers can become proficient with the framework in as little time as possible.

### Strict typing for `@angular/forms`

We will work on implementing stricter type checking for reactive forms. This way, we will allow developers to catch more issues during development time, enable better text editor and IDE support, and improve the type checking for reactive forms.

### webpack 5 in the Angular CLI

Webpack 5 brings a lot of build speed and bundle size improvements. To make them available for Angular developers, we will invest in migrating Angular CLI from using deprecated and removed webpack APIs.

### Commit message standardization

We want to unify commit message requirements and conformance across Angular repositories ([angular/angular](https://github.com/angular/angular), [angular/components](https://github.com/angular/components), [angular/angular-cli](https://github.com/angular/angular-cli)) to bring consistency to our development process and reuse infrastructure tooling.

### Optional Zone.js

We are going to design and implement a plan to make Zone.js optional from Angular applications. This way, we will simplify the framework, improve debugging, and reduce application bundle size. Additionally, this will allow us to take advantage of native async/await syntax, which currently Zone.js does not support.

### Remove legacy [View Engine](guide/ivy)

After the transition of all our internal tooling to Ivy has completed, we want to remove the legacy View Engine for smaller Angular conceptual overhead, smaller package size, lower maintenance cost, and lower complexity of the codebase.

### Angular DevTools

We’ll be working on development tooling for Angular that will provide utilities for debugging and performance profiling. This project aims to help developers understand the component structure and the change detection in an Angular application.

### Optional NgModules

To simplify the Angular mental model and learning journey, we’ll be working on making NgModules optional. This work will allow developers to develop standalone components and implement an alternative API for declaring the component’s compilation scope.

### Ergonomic component level code-splitting APIs

A common problem of web applications is their slow initial load time. A way to improve it is to apply more granular code-splitting on a component level. To encourage this practice, we’ll be working on more ergonomic code-splitting APIs.

### Migration to ESLint

With the deprecation of TSLint we will be moving to ESLint. As part of the process, we will work on ensuring backward compatibility with our current recommended TSLint configuration, implement a migration strategy for existing Angular applications and introduce new tooling to the Angular CLI toolchain.

repository: angular-hispano/angular

gha_language: TypeScript

repo_name: angular-hispano/angular


text:
# Release Process

## Setup
Choose a new version for the release.  It is best to set this to an environment variable
as we will be referring to it often

```bash
export newVersion=1.0.0
```

## Set the release version
Set the version of the poms to the release artifact version

```bash
./mvnw versions:set -DnewVersion=${newVersion} -DgenerateBackupPoms=false
```

## Build and Test
Build and test the release to ensure everything is correct

```bash
./mvnw clean install -Prelease
```

Update the tests to point to release and test:

```bash
./mvnw -f tests/pom.xml clean install
```

## Verify the GPG Signature
Verify the correct signature was used to sign the artifacts

```bash
gpg --verify target/maven-parent-${newVersion}.pom.asc
```

## Deploy the Release to Stagging
Deploy the release as a stagged release to Sonatype

```bash
./mvnw clean deploy -Prelease
```

If everything goes well, we’ll see, among the console outputs, the staging repository id created for the project like this:

```bash
* Created staging repository with ID "io.github.efenglu-1001".
```

## Inspect the stagged artifacts
Inspect the artifacts on Sonatype ensure they are correct

Let’s log in to [https://oss.sonatype.org](https://oss.sonatype.org) to
inspect the artifacts we’ve deployed to staging. After login, we’ll click on
Staging Repositories on the left side menu under the Build Promotion sub-menu and using the
search bar at the top right of the page, we’ll search for the staging repository ID
created e.g. **io.github.efenglu-1001** in this case.

We should be able to see and inspect the artifacts that were uploaded by the nexus staging Maven plugin.

If everything looks right select the stagged repository and click the **close** button.

## Commit and Tag Release
Git and tag the release to Github

```bash
git add .
git commit -m "Release ${newVersion}"
git tag ${newVersion}
git push --tags
# Roll back all the changes so they don't get added to the main codebase
git reset HEAD~1
git checkout .
git clean -fd
```

## Deploy the Release
Everything is good to go.  Mark the release to be deployed to central.

```bash
./mvnw nexus-staging:release -Prelease -DstagingRepositoryId=iogithubefenglu-1000
```

repository: efenglu/japicc-plugin

repo_name: efenglu/japicc-plugin


text:
# A Network Tour of Data Science, edition 2017

[![Binder](https://mybinder.org/badge.svg)][binder_lab]
  (Jupyter [lab][binder_lab] or [notebook][binder_notebook])

[binder_lab]: https://mybinder.org/v2/gh/mdeff/ntds_2017/outputs?urlpath=lab
[binder_notebook]: https://mybinder.org/v2/gh/mdeff/ntds_2017/outputs?urlpath=tree

This repository contains the material for the practical work associated with the EPFL
master course [EE-558 A Network Tour of Data Science][epfl] ([moodle]), taught
in fall 2017. Compared to the [2016 edition], the course has been refocused
on graph and network sciences. It is further developed in the [2018 edition].
The course material revolves around the following topics:

1. [Network Science](https://en.wikipedia.org/wiki/Network_science),
1. [Spectral Graph Theory](https://en.wikipedia.org/wiki/Spectral_graph_theory),
1. [Graph Signal Processing](https://arxiv.org/abs/1211.0053),
1. [Data Science](https://en.wikipedia.org/wiki/Data_science),
1. [Machine Learning](https://en.wikipedia.org/wiki/Machine_learning).

Theoretical knowledge is taught during lectures.
Practical knowledge is taught through [tutorials](#tutorials).
Both are practiced and evaluated through [four assignments](#assignments) and a [semester project](#projects).

[epfl]: http://edu.epfl.ch/coursebook/en/a-network-tour-of-data-science-EE-558
[moodle]: http://moodle.epfl.ch/course/view.php?id=15299
[2016 edition]: https://github.com/mdeff/ntds_2016
[2018 edition]: https://github.com/mdeff/ntds_2018

## Tutorials

Below is the teaching material you'll find in this repository.

1. [Practical informations][practical_info]
1. [Installation instructions](#installation)
1. [Introduction][d01]: conda & Anaconda, Python, Jupyter, git, scientific Python
1. [Data acquisition from Twitter][d02]
1. [Numerical computing with numpy][d03]
1. [Network models and properties with networkx][d04]
1. [Plotting with matplotlib][d05]
1. [Web APIs and data analysis with pandas][d06]
1. [Data exploration and visualization][d07]
1. [Graph signal processing with the PyGSP][d08]
1. [Concluding remarks][conclusion]

[practical_info]: https://github.com/mdeff/ntds_2017/blob/outputs/slides/ntds_labs.pdf
[conclusion]: https://github.com/mdeff/ntds_2017/raw/outputs/slides/ntds_conclusion.pdf

[d01]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/01_introduction.ipynb
[d02]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/02_data_acquisition_twitter.ipynb
[d03]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/03_numpy.ipynb
[d04]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/04_networkx.ipynb
[d05]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/05_matplotlib.ipynb
[d06]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/06_webapi_pandas.ipynb
[d07]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/07_data_exploration_and_visualisation.ipynb
[d08]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/demos/08_pygsp.ipynb

## Assignments

The following assignments were designed to evaluate the theoretical understanding of students through practice.
As a Data Science course, those activities are realized on real data and networks.

1. Network properties: [assignment][a01], [solution][a01s1], [student solution][a01s2], [feedback][a01fb]
1. Network models: [assignment][a02], [solution][a02s]
1. Spectral graph theory: [assignment][a03], [solution][a03s], [feedback][a03fb]
1. Graph signal processing: [assignment][a04], [solution][a04s], [feedback][a04fb]

[a01]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/01_network_properties.ipynb
[a01s1]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/01_solution_ersi.ipynb
[a01s2]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/01_solution_florian.ipynb
[a01fb]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/01_feedback.ipynb
[a02]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/02_network_models.ipynb
[a02s]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/02_solution.ipynb
[a03]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/03_spectral_graph_theory.ipynb
[a03s]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/03_solution.ipynb
[a03fb]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/03_feedback.ipynb
[a04]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/04_graph_signal_processing.ipynb
[a04s]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/04_solution.ipynb
[a04fb]: https://nbviewer.jupyter.org/github/mdeff/ntds_2017/blob/outputs/assignments/04_feedback.ipynb

## Projects

Part of the course is evaluated by an open-ended project (see the [description][projects]),
proposed and carried out by groups of three to four students.

[projects]: https://github.com/mdeff/ntds_2017/raw/outputs/slides/ntds_projects.pdf

Below is their work.

* [[proposal][01p], [analysis][01r], [slides][01s]] American Basketball Players
* [[proposal][02p], [analysis][02r], [slides][02s]] Graph-based Nutrition Guide
* [[proposal][03p], [analysis][03r], [slides][03s]] What Impacts the Success of a Movie?
* [[proposal][04p], [analysis][04r], [slides][04s]] Exploring the Crunchbase Dataset to Detect High Potential Startups
* [[proposal][05p], [analysis][05r], [slides][05s]] Beer Suggester
* [[proposal][06p], [analysis][06r], [slides][06s]] Swiss Political Survey
* [[proposal][07p], [analysis][07r], [slides][07s]] A StackOverflow Recommender System
* [[proposal][08p], [analysis][08r], [slides][08s]] Analysis of World Development Indicators as Predictors
* [[proposal][09p], [analysis][09r], [slides][09s]] Satellites Characterization – Clustering using Orbital Characteristics
* [[proposal][10p], [analysis][10r], [slides][10s]] Amazon Electronic Products – Network Analysis
* [[proposal][11p], [analysis][11r], [slides][11s]] GSP on the Digital Reconstruction of the Brain
* [[proposal][12p], [analysis][12r], [slides][12s]] Movie Recommendation
* [[proposal][13p], [analysis][13r], [slides][13s]] GraphLang
* [[proposal][14p], [analysis][14r], [slides][14s]] Buda + Pest = Budapest
* [[proposal][15p], [analysis][15r], [slides][15s]] Manifold Learning of Face Data
* [[proposal][16p], [analysis][16r], [slides][16s]] A Network Tour of the Tunisian and Egyptian Springs
* [[proposal][17p], [analysis][17r], [slides][17s]] StackOverflow Survey
* [[proposal][18p], [analysis][18r], [slides][18s]] Speech Recognition Challenge
* [[proposal][19p], [analysis][19r], [slides][19s]] Analysis of the Elite Football Transfer Market
* [[proposal][20p], [analysis][20r], [slides][20s]] Titanic
* [[proposal][21p], [analysis][21r], [slides][21s]] This is My Jam
* [[proposal][22p], [analysis][22r], [slides][22s]] A Network Tour of StackOverflow
* [[proposal][23p], [analysis][23r], [slides][23s]] Course Suggester
* [[proposal][24p], [analysis][24r], [slides][24s]] Spectral Analysis of 5000 Movies Network
* [[proposal][25p], [analysis][25r], [slides][25s]] Community Detection on the Wikipedia Hyperlink Graph
* [[proposal][26p], [analysis][26r], [slides][26s]] 3D Meshes of Facial Expression
* [[proposal][27p], [analysis][27r], [slides][27s]] Terrorist Attacks
* [[proposal][28p], [analysis][28r], [slides][28s]] Community Detection and Labelling in an Instagram Network
* [[proposal][29p], [analysis][29r], [slides][29s]] Graph-based Recommendation for lastFM

[01p]: projects/proposals/basketball_players.pdf
[02p]: projects/proposals/nutrition_guide.pdf
[03p]: projects/proposals/movie_success.pdf
[04p]: projects/proposals/crunchbase_startups.pdf
[05p]: projects/proposals/beer_suggester.pdf
[06p]: projects/proposals/swiss_politics.pdf
[07p]: projects/proposals/stackoverflow_recommendation.pdf
[08p]: projects/proposals/countries_development.pdf
[09p]: projects/proposals/satellites.pdf
[10p]: projects/proposals/amazon_products.pdf
[11p]: projects/proposals/brain_network.pdf
[12p]: projects/proposals/movie_recommendation.pdf
[13p]: projects/proposals/graphlang.pdf
[14p]: projects/proposals/road_network.pdf
[15p]: projects/proposals/face_manifold.pdf
[16p]: projects/proposals/arab_springs.pdf
[17p]: projects/proposals/stackoverflow_survey.pdf
[18p]: projects/proposals/speech_recognition.pdf
[19p]: projects/proposals/football_transfers.pdf
[20p]: projects/proposals/titanic.pdf
[21p]: projects/proposals/jam.pdf
[22p]: projects/proposals/stackoverflow_network.pdf
[23p]: projects/proposals/course_suggester.pdf
[24p]: projects/proposals/movie_network.pdf
[25p]: projects/proposals/wikipedia_hyperlink.pdf
[26p]: projects/proposals/facial_expression.pdf
[27p]: projects/proposals/terrorist_attacks.pdf
[28p]: projects/proposals/instagram_community.pdf
[29p]: projects/proposals/lastfm_recommendation.pdf

[01s]: projects/slides/basketball_players.pdf
[02s]: projects/slides/nutrition_guide.pdf
[03s]: projects/slides/movie_success.pdf
[04s]: projects/slides/crunchbase_startups.pdf
[05s]: projects/slides/beer_suggester.pdf
[06s]: projects/slides/swiss_politics.pdf
[07s]: projects/slides/stackoverflow_recommendation.pdf
[08s]: projects/slides/countries_development.pdf
[09s]: projects/slides/satellites.pdf
[10s]: projects/slides/amazon_products.pdf
[11s]: projects/slides/brain_network.pdf
[12s]: projects/slides/movie_recommendation.pdf
[13s]: projects/slides/graphlang.pdf
[14s]: projects/slides/road_network.pdf
[15s]: projects/slides/face_manifold.pdf
[16s]: projects/slides/arab_springs.pdf
[17s]: projects/slides/stackoverflow_survey.pdf
[18s]: projects/slides/speech_recognition.pdf
[19s]: projects/slides/football_transfers.pdf
[20s]: projects/slides/titanic.pdf
[21s]: projects/slides/jam.pdf
[22s]: projects/slides/stackoverflow_network.pdf
[23s]: projects/slides/course_suggester.pdf
[24s]: projects/slides/movie_network.pdf
[25s]: projects/slides/wikipedia_hyperlink.pdf
[26s]: projects/slides/facial_expression.pdf
[27s]: projects/slides/terrorist_attacks.pdf
[28s]: projects/slides/instagram_community.pdf
[29s]: projects/slides/lastfm_recommendation.pdf

[01r]: projects/reports/basketball_players
[02r]: projects/reports/nutrition_guide
[03r]: projects/reports/movie_success
[04r]: projects/reports/crunchbase_startups
[05r]: projects/reports/beer_suggester
[06r]: projects/reports/swiss_politics
[07r]: projects/reports/stackoverflow_recommendation
[08r]: projects/reports/countries_development
[09r]: projects/reports/satellites
[10r]: projects/reports/amazon_products
[11r]: projects/reports/brain_network
[12r]: projects/reports/movie_recommendation
[13r]: projects/reports/graphlang
[14r]: projects/reports/road_network
[15r]: projects/reports/face_manifold
[16r]: projects/reports/arab_springs
[17r]: projects/reports/stackoverflow_survey
[18r]: projects/reports/speech_recognition
[19r]: projects/reports/football_transfers
[20r]: https://github.com/zifeo/Titanic
[21r]: projects/reports/jam
[22r]: projects/reports/stackoverflow_network
[23r]: projects/reports/course_suggester
[24r]: projects/reports/movie_network
[25r]: projects/reports/wikipedia_hyperlink
[26r]: projects/reports/facial_expression
[27r]: projects/reports/terrorist_attacks
[28r]: projects/reports/instagram_community
[29r]: projects/reports/lastfm_recommendation

## Installation

Click the [binder badge][binder_lab] to play with the notebooks from your
browser without installing anything.

For a local installation, you will need [git], [Python], and packages from the
[Python scientific stack][scipy]. If you don't know how to install those on
your platform, we recommend to install [Miniconda], a distribution of the
[conda] package and environment manager. Please follow the below instructions
to install it and create an environment for the course.

1. Download the Python 3.x installer for Windows, macOS, or Linux from
   <https://conda.io/miniconda.html> and install with default settings. Skip
   this step if you have conda already installed (from [Miniconda] or
   [Anaconda]). Linux users may prefer to use their package manager.
   * Windows: Double-click on the `.exe` file.
   * macOS: Run `bash Miniconda3-latest-MacOSX-x86_64.sh` in your terminal.
   * Linux: Run `bash Miniconda3-latest-Linux-x86_64.sh` in your terminal.
1. Open a terminal. Windows: open the Anaconda Prompt from the Start menu.
1. Install git with `conda install git`.
1. Download this repository by running
   `git clone --recurse-submodules https://github.com/mdeff/ntds_2017`.
1. Create an environment with the packages required for the course with
   `conda env create -f ntds_2017/environment.yml`.

Every time you want to work, do the following:

1. Open a terminal. Windows: open the Anaconda Prompt from the Start menu.
1. Activate the environment with `conda activate ntds_2017`
   (or `activate ntds_2017`, or `source activate ntds_2017`).
1. Start Jupyter with `jupyter notebook` or `jupyter lab`. The command should
   open a new tab in your web browser.
1. Edit and run the notebooks from your browser.

[git]: https://git-scm.com
[python]: https://www.python.org
[scipy]: https://www.scipy.org
[anaconda]: https://anaconda.org
[miniconda]: https://conda.io/miniconda.html
[conda]: https://conda.io
[conda-forge]: https://conda-forge.org

## Team

* Instructors:
[Pierre Vandergheynst](https://people.epfl.ch/pierre.vandergheynst),
[Pascal Frossard](https://people.epfl.ch/pascal.frossard).
* Assistants:
[Michaël Defferrard](http://deff.ch),
[Hermina Petric Maretic](https://people.epfl.ch/hermina.petricmaretic),
[Effrosyni Simou](https://people.epfl.ch/effrosyni.simou).
* Invited lecturers:
[Igor Perisic](https://www.linkedin.com/in/igorperisic),
[Kirell Benzi](https://www.kirellbenzi.com),
[Dorina Thanou](https://people.epfl.ch/dorina.thanou),
[Michaël Defferrard](http://deff.ch).

## License

The content is released under the terms of the [MIT License](LICENSE.txt).


text:
# Change Log for dash-select-material
All notable changes to this project will be documented in this file.
This project adheres to [Semantic Versioning](http://semver.org/).

## Unreleased

### Added
- Feature x

### Fixed
- Bug y

## 0.0.1 - 2018-05-30
- Initial release

[Unreleased]: https://github.com/ssword/dash-select-material/v0.0.1...HEAD

repository: ssword/dash-multiselect-material

repo_name: ssword/dash-multiselect-material


text:
---
title: How to pass arguments to a Rake task
description: There are many ways how to pass an argument to a rake task, some of these are covered in at this blog post.
updated: 2016-08-08 23:37
---

<small>
  ![Osaka Prefecture, Japan](/assets/2018-08-08-how-to-pass-argument-to-a-rake-task/1.jpg "Osaka Prefecture, Japan")
  *Photo by [Lukas](https://unsplash.com/photos/80UpjrtFxLA?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/search/photos/tokio-night?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)*
</small>

There are many ways how to pass an argument to a rake task, some of these are covered in at this [blog post](https://cobwwweb.com/4-ways-to-pass-arguments-to-a-rake-task).

IMHO, the most elegant way to do this is using the first way described at post, the [Rake Way](https://cobwwweb.com/4-ways-to-pass-arguments-to-a-rake-task#method-1-the-rake-way):

```ruby
  task :add, [:num1, :num2] do |_, args|
    puts args[:num1].to_i + args[:num2].to_i
  end
```

And, you run it…

```bash
  $ rake add[1,2]
  # => 3
```

All right! Nothing to do here! YAY!

A common task block is like this:

```ruby
  task some_task: :environment do
    # Do awesome things...
  end
```

The `:environment` symbol is what tells to rake task to [load your entire Rails environment](https://stackoverflow.com/questions/7044714/whats-the-environment-task-in-rake/18617481#18617481). So, without this you can't access your models, for example.

To using arguments in a elegant way and load your Rails environment in your Rake task, you can write your task method like this:

```ruby
  task :add, [:num1, :num2] => :environment do |_, args|
    puts args[:num1].to_i + args[:num2].to_i
  end
```

And, this is the output:

```shell
  $ rake add[1,2]
  # => 3
```

Thanks! 😄

### References:

  - [4 Ways to Pass Arguments to a Rake Task](https://cobwwweb.com/4-ways-to-pass-arguments-to-a-rake-task#method-1-the-rake-way)
  - [How to pass arguments into a Rake task with environment in Rails?](https://stackoverflow.com/questions/1357639/how-to-pass-arguments-into-a-rake-task-with-environment-in-rails/5393324#5393324)
  - [What's the 'environment' task in Rake?](https://stackoverflow.com/questions/7044714/whats-the-environment-task-in-rake/18617481#18617481)

gha_language: CSS


text:
Two threes.

Six is the factorial of 3, and the first perfect number apart from 1; it
is also the third triangular number.

The first number after 1 which is not a power of a prime number.

It is the only perfect number which is not the sum of consecutive cubes.

It is the second primorial number.

It is the product of 1,2,3 and the sum of 1,2 3 (no other number has
such a property).

It is the second automorphic number.

6 is triangular, and its square is also a triangular number.

It is the number of faces or vertices of both the cube and the
octahedron, and it is the number of edges of the tetrahedron.

It is the number of different 4-dimensional polytopes.

$ \phi(6)=2, \quad d(6)=4, \quad \sigma(6)=12 . $


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [prosemirror-suggest](./prosemirror-suggest.md) > [getSuggestPluginState](./prosemirror-suggest.getsuggestpluginstate.md)

## getSuggestPluginState variable

Get the state of the suggest plugin.

<b>Signature:</b>

```typescript
getSuggestPluginState: <GSchema extends EditorSchema<string, string> = any>(state: Readonly<import("prosemirror-state").EditorState<GSchema>>) => SuggestState<any>
```

repository: tomas-c/remirror

repo_name: tomas-c/remirror


text:
# Prediction-of-House-Prices-
# Hass Consulting Company Analysis
#
### Moringa_Data_Science_Core_W6_Independent_Project_2020_07_Leah_Mbugua_Python_Notebook

### {Hass Consulting Company dataset }

#### {IP WEEK 7 DATA SCIENCE CORE}, {January, 2020}

## Description

 * A prediction of the sale of prices upon being provided with the predictor variables.

* Overview

As a Data Scientist, you work for Hass Consulting Company which is a real estate leader with over 25 years of experience. You have been tasked to study the factors that affect housing prices using the given information on real estate properties that was collected over the past few months.

Within your deliverable you are expected to:

Define the question, the metric for success, the context, experimental design taken.
Read and explore the given dataset.
Define the appropriateness of the available data to answer the given question.
Find and deal with outliers, anomalies, and missing data within the dataset.
Perform univariate, bivariate and multivariate analysis recording your observations.
Performing regression analysis.
Incorporate categorical independent variables into your models.
Check for multicollinearity
Provide a recommendation based on your analysis.
Create residual plots for your models, and assess heteroskedasticity using Barlett's test.
Challenge your solution by providing insights on how you can make improvements in model improvement.

## Experimental Design

 * Exploratory Data Analysis.

 * Data Cleaning.

 * Univariate, and Bivariate Analysis.

 * Visualizations.

 * Approach 1 Multiple Linear regression.

 * Approach 2 Quantile Regression

 * Approach 3 Ridge Regression

 * Approach 4 Lasso Regression

 * Approach 5 Elastic Net Regression

 * Findings and Recommendations

## Setup/Installation Requirements

* Google colab/jupyter notebook
* Python basics
* Python libraries
* Github

### License

*{MIT License.  See below for more details on licensing.}*

Copyright (c) {2019} **{Moringa School Data Science Core 2}**
* Github

## Known Bugs

{There are no known bugs in this project. }

## Technologies Used

{Python}


text:
+++
title = "Shishir Mehrotra of Coda"
type = "podcast"
hero = ""
metadescription = "The EnterpriseReady Podcast is a show aiming to change the enterprise software narrative from how to sell to the enterprise, to how to build for the enterprise."
pagetitle = "Shishir Mehrotra of Coda Interview - EnterpriseReady Podcast"
ogimage = "podcast/images/podcast_og.png"
image = "/podcast/images/episodes/shishir-mehrotra.jpg"
weight = "33"
+++

{{< soundcloud soundcloud-url="https://w.soundcloud.com/player/?url=https%3A//api.soundcloud.com/tracks/909261313&color=%23ff5500&auto_play=false&hide_related=false&show_comments=true&show_user=true&show_reposts=false&show_teaser=true&visual=true" >}}

\
In episode 33 of EnterpriseReady, Grant is joined by Shishir Mehrotra of Coda. They discuss important lessons for building and launching products, as well as Shishir’s role as a technology leader at YouTube in it’s pivotal early years, just after the Google acquisition.

## About the guest

[Shishir Mehrotra](https://twitter.com/shishirmehrotra) is the Co-Founder and CEO of [Coda](https://coda.io/), a cloud-based document editor. He was previously the Director of Product Management at [YouTube](https://youtube.com/), and in years prior, Shishir was the Director of Program Management at [Microsoft](http://microsoft.com/).

repository: enterpriseready/enterpriseready

repo_name: enterpriseready/enterpriseready


text:
# paint-magic
A painting tool that generates inverse "snapped" effect using linear interpolation.

![sample](https://i.imgur.com/vr2pmTU.gif)

## Requirements
  * `Python 3.6.x` or higher
  * `pygame 1.9.x` or higher
  * `Pillow 8.x` or higher. (Not necessary, but required to save the animation as a GIF)

## How to use:
`Left Mouse Button`         : Paint pixels

`Right Mouse Button`        : Erase pixels

`Right and Left arrow keys` : change colors

`Up and Down arrow keys`    : change brush size

`Spacebar`                  : Play or repeat the animation.

## Features:
 * Highly configurable
 * Can output the animation as a .GIF with various level of smoothness using ``optimization-level`` parameter (WIP)

gha_language: Python