text:
---
author:
comments: true
date: 2009-04-14 14:39:45
layout: post
slug: john-maddox
title: John Maddox
wordpress_id: 1473
categories:
- General
---

Not nice to discover _via_ Pharyngula that [John Maddox has died](http://scienceblogs.com/pharyngula/2009/04/john_maddox_dead_at_84.php). Unsurprisingly, PZ and his commenters [^fn1] major on John's forceful way with charlatans and the self-deluded. (By the way, is it too much to hope that Brenda Maddox will give her side of how it was that John came to call in James "The Amazing" Randi to investigate Jacques Benveniste's claims in support of homoeopathy?) But I knew another John, who really was a lion, and who didn't care that his comment probably gave Rupert Sheldrake more publicity than Sheldrake's ideas could ever have mustered without Maddox wading in. "It's crap," he told me (or words to that effect).

"Then why not ignore it?"

"Because someone had to say something."

It's said that a letter addressed to _Nature_ at Little Ethics Street, London (when it was at Little Essex St) found the Great Man in record time.

My own favourite Maddox story is a FOAF tale, and I can't vouch for it exactly. It's said that John was never entirely _au fait_ with the latest technology, and back in the day some unnamed scientist ((A friend of a friend ...) submitted a paper to _Nature_. John was keen to publish but, he told the FOAF, "It's too long. You need to shorten it by a third."

"So," said the FOAF, who had been using one of those new-fangled wordly processing thingies, "I moved the margins out a bit and decreased the font size until it fitted in two thirds of the original space. Then I sent it back to John."

"Splendid," came the reply. "And thank you for your efforts. We''ll be publishing it as soon as we can."

As I say, I can't prove the truth of that, but the story certainly ought to be true.

The [Times of London](http://www.timesonline.co.uk/tol/comment/obituaries/article6087234.ece?token=null&offset=12&page=2) and [The Times of New York](http://www.nytimes.com/2009/04/14/science/14maddox.html?_r=1&partner=rss&emc=rss&pagewanted=all) have done him. I hope The Economist does too.

[^fn1]: And who ever thought that requiring registration would keep the nuts out?

repository: jeremycherfas/myocto

extension: markdown

repo_name: jeremycherfas/myocto


text:
This is my work for the Compiler course at UVic. The objective is to write a compiler for a C-like but much simpler programming language using Antlr (https://www.antlr.org/) as front-end tool for lexical, syntax and semantic analysis.

This language, however, allows `string` as a type (not `char[]`).

The grammer is written in Antlr 3.5.2 for learning purpose. A reason is 3.5.2 doesn't support left-recursive rules, you'll have to learn how to elimiate left-recursion and establish precedence rules for operators (+, -, *, //, ...). From Antlr 4, it makes your life much easier (https://github.com/antlr/antlr4/blob/master/doc/left-recursion.md).

`export CLASSPATH=".:/usr/local/lib/antlr-3.5.2-complete.jar:$CLASSPATH"`

## Lexical and syntax analysis

## Semantic analsysis

### Type checking

Suppose we have a function written in this language to compute factorials.

```
int factorial(int n)
{
	int returnValue;

	if (n == 1)
	{
		returnValue = 1;
	}
	else
	{
		returnValue =  n*factorial(n-1);
	}
	return returnValue;
}

void main()
{
	print "The factorial of 9 is ";
	println factorial(9);
}
```

### Intermediate Representation

The generated IR is:
```
PROG factorial
FUNC factorial (I)I
{
    TEMP 0:I;
    TEMP 1:I;
    TEMP 2:I;
    TEMP 3:Z;
    TEMP 4:I;
    TEMP 5:I;
    TEMP 6:I;
    TEMP 7:I;
    TEMP 8:I;
        T2 := 1;
        T3 := T0 I== T2;
        T3 := Z! T3;
        IF T3 GOTO L0;
        T4 := 1;
        T1 := T4;
        GOTO L1;
L0:;
        T5 := 1;
        T6 := T0 Isub T5;
        T7 := CALL factorial(T6);
        T8 := T0 Imul T7;
        T1 := T8;
L1:;
        RETURN T1;
}
FUNC main ()V
{
    TEMP 0:U;
    TEMP 1:I;
    TEMP 2:I;
        T0 := "The factorial of 9 is ";
        PRINTU T0;
        T1 := 9;
        T2 := CALL factorial(T1);
        PRINTLNI T2;
        RETURN;
}
```

### JVM Bytecode Generation

The generated JVM bytecode is:
```
.source factorial.ir
.class public factorial
.super java/lang/Object
.method public static factorial(I)I
    .limit stack 16
    .limit locals 9
    ldc 1
    istore 2
    iload 0
    iload 2
    isub
    ifeq L_0
    ldc 0
    goto L_1
L_0:
    ldc 1
L_1:
    istore 3
    iload 3
    ldc 1
    ixor
    istore 3
    iload 3
    ifne L0
    ldc 1
    istore 4
    iload 4
    istore 1
    goto L1
L0:
    ldc 1
    istore 5
    iload 0
    iload 5
    isub
    istore 6
    iload 6
    invokestatic factorial/factorial(I)I
    istore 7
    iload 0
    iload 7
    imul
    istore 8
    iload 8
    istore 1
L1:
    iload 1
    ireturn
.end method
.method public static __main()V
    .limit stack 16
    .limit locals 3
    ldc "The factorial of 9 is "
    astore 0
    getstatic java/lang/System/out Ljava/io/PrintStream;
    aload 0
    invokevirtual java/io/PrintStream/print(Ljava/lang/String;)V
    ldc 9
    istore 1
    iload 1
    invokestatic factorial/factorial(I)I
    istore 2
    getstatic java/lang/System/out Ljava/io/PrintStream;
    iload 2
    invokevirtual java/io/PrintStream/println(I)V
    return
.end method

;--------------------------------------------;
;                                            ;
; Boilerplate                                ;
;                                            ;
;--------------------------------------------;

.method public static main([Ljava/lang/String;)V
    ; set limits used by this method
    .limit locals 1
    .limit stack 4
    invokestatic factorial/__main()V
    return
.end method

; standard initializer
.method public <init>()V
    aload_0
    invokenonvirtual java/lang/Object/<init>()V
    return
.end method
```
The above Bytecode can be compiled to an executable class file by Jasmin (http://jasmin.sourceforge.net/)

license: MIT

repository: phucnm/compiler-course

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: phucnm/compiler-course


text:
#CHANGELOG
* *0.6.0* Moved to actually using a link to a blob url to hold style info with all styles as css classes.
* *0.5.0* Moved styles into a more maintainable pattern
	* Updated dependencies to remove any recursion.
* *0.4.1* Added support for pre-es6(2015) browsers with babel transpilation.

repository: WandCorp/quickConsole

repo_name: WandCorp/quickConsole


text:
# Python Versions

## Python2 vs Python3

- Python 2 automatically performs integer arithmetic if both operands are integers

## New in python3.7

1. contextvars
2. dataclasses
3. **ordered dictionaries by default** (OrderedDict**preserves the order**in which the keys are inserted. A regular dict doesn't track the insertion order, and iterating it gives the values in an arbitrary order. By contrast, the order the items are inserted is remembered by OrderedDict.)

<https://docs.python.org/3/whatsnew/3.7.html>

## Why to move to Python3.7

- Fast
- Data Classes
- f-strings
- dropping support
- django support dropping for advanced versions
- **type annotations**

## Libraries for migrations

- **Six--** best for adding Python 3 compatibility to your existing Python 2 code.
- **2to3--** best for converting Python 2 code to Python 3 code.
- **Python-future--** best for those that want to focus on writing python 3 code going forward while ensuring backward compatibility with Python 2.

## Must use Python 3 Features

1. f-strings (3.6+)
2. Pathlib (3.4+)
3. Type hinting (3.5+)

    ```python
    def sentence_has_animal(sentence: str) -> bool:
        return "animal" in sentence
    ```

4. Enumerations (3.4+)
5. **Built-in LRU cache (3.2+)**

    Using decorator `@lru_cache(maxsize=512)`

6. Extended iterable unpacking (3.0+)
7. Data Classes (3.7+)
8. Implicit namespace packages (3.3+)

<https://datawhatnow.com/things-you-are-probably-not-using-in-python-3-but-should>

## Python 3.8

## Assignment Expression (Walrus operator)

```python
val = func1()
if not val:
    logging.warning('func1 no good')
    val = func2()
    if not val:
        logging.warning('func2 no good')
        val = func3()
if not val:
    raise ValueError('All went south')

# Do something with val after
```

After upgrading to 3.8, you could refactor it to:

```python
if not (val := func1()):
    logging.warning('func1 no good')
    if not (val := func2()):
        logging.warning('func2 no good')
        if not (val := func3()):
            raise ValueError('All went south')
# Do something with val after
```

## Positional Only Arguments

```python
def func(a, /):
    pass

func('foobar')
func(a='foobar') # This raises
```

## Runtime Audit Hooks

<https://docs.python.org/3/whatsnew/3.8.html>

## Python 3.9

- Dictionary Union Operators

    ```python
    a = {1: 'a', 2: 'b', 3: 'c'}
    b = {4: 'd', 5: 'e'}
    c = a | b
    print(c)
    [Out]: {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

    a = {1: 'a', 2: 'b', 3: 'c', 6: 'in both'}
    b = {4: 'd', 5: 'e', 6: 'but different'}
    print(a | b)
    [Out]: {1: 'a', 2: 'b', 3: 'c', 6: 'but different', 4: 'd', 5: 'e'}
    ```

- Type Hinting
- Two New String Methods

    ```python
    "Hello world".removeprefix("He")
    "Hello world".removesuffix("ld")
    ```

- New Python Parser

    The new parser, based on PEG, will allow the Python developers significantly more flexibility

gha_language: JavaScript

gha_license_id: MIT


text:
---
layout: paper
title: A Generative Middleware for Heterogeneous and Distributed Services
categories: [paper, conference]
---
**B. Morin**, F. Fleurey, K.E. Husa, and O. Barais.

In _CBSE'16: 19th International ACM Sigsoft Symposium on Component-Based Software Engineering_

Venice, Italy, April 5-8, 2016

[PDF](https://drive.google.com/file/d/0B8COpPaPIDHYMFdKLS1LVjg1T28/view)


text:
# alexa-Music-Lamp
Sound reactive led lamp using esp8266(NODE MCU). which can be controlled via alexa

## Hardware Used
* NODEMCU(esp8266)
* ws2812B leds
* arduino microphone module

## Circuit Connection

* Connect Nodemcu vin to led strip 5v input
* Connect Nodemcu GND to led strip GND input
* Connect Nodemcu D4 to led strip data input

* Connect Nodemcu 3.3v to microphone VCC pin
* Connect Nodemcu GND to microphone GND pin
* Connect Nodemcu A0 to microphone analog output A0

## Software
### prerequisite
  * Arduino IDE
  * Follow this [guide|https://randomnerdtutorials.com/how-to-install-esp8266-board-arduino-ide/] for Installing ESP8266 Board in Arduino IDE
  * Install FastLED library  (Tools->Manage Libraries.search for FastLED)
  * Espalexa library (Tools->Manage Libraries.search for Espalexa)

 ### Code
 * Download `esp8266_alexa_lamp.ino` and `reactive_common.h`
 * Change Wifi ssid/password(variables `WIFI_SSID` and `WIFI_PASSWORD`), led type and no of led(variables `NUMLEDS`, `LED_TYPE`, `COLOR_ORDER`)
 * Connect and Upload to NODEMCU.

## Alexa
* Open Alexa app and search for new devices(type `other`) and add them.
* Commands supported are `Alexa lamp On/Off`, `Alexa lamp colour <colour>` , `Alexa lamp brightness 0-100%` , `Alexa disco On/Off`

branch_name: refs/heads/main


text:
---
layout: post
title: "2.2 Figuring out problems"
date: 2003-05-05 09:40
comments: true
categories: Diploma - Block 2
author: Oliver Thylmann
---

This booklet includes two case studies.

A: The wrong number planning problem
This about a company that outsourced its computer needs and now want to shut down the operation again due to the loss it makes. The general revenue and loss figures are not meaningful here though because it should be looked at what the mother company looses when the shop is closed. It would probably have to pay more for the services on the market. On top of that it needs to be made clear what the real costs are and what the contribution is to find out how many real hours are needed to brake even, which is harder if there is the mix of direct relations to the Mother Company as well as commercial services.

B: The shock results problem
Here a company seems to be on the brink of recovery but a closer variance analysis reviews something else. Important here is to split everything up for product group so that you see which costs should come to which products and which revenue to which products to see the profit and loss on a per product basis. You need to look at volume and price variance, meaning changes in revenue/profit based on changes therein. It is important to split the figures into manageable parts that are relevant to monitoring.

Here it is important that financial calculations and analysis can be used to improve organisational performance. Cost analysis should help better understand contributions of products and services and with the ideas you get, find techniques and applications of interest.


text:
# How to clean TizenRT

There are two types of commands on Makefile to clean all of made files.
One is ```make clean```, and the other is ```make distclean```. They are executed on *os* folder.

## make clean
This command removes files which are made on build procedure like objects, libraries, .depend, Make.dep and etc.
When configuration is changed, executing this command guarantees a re-build from scratch.

## make distclean
This command includes ```make clean``` inside. Additionally, it removes configured files like .config and Make.defs.
When you want to use new or another defconfig, this should be executed before configuring new one.

repository: Samsung/TizenRT

gha_language: C

repo_name: Samsung/TizenRT


text:
# aggregate-reduce

Perform aggregate reduce operations on MongoDB.

Mongo's aggregation framework is way faster than MapReduce, however it lacks the ability to reduce aggregations incrementally.

This module adds the ability to perform aggregations and reduce it into a collection of a choice.

## Usage:

### aggregateReduce(collection, pipelineArray, map, reduce, options)

Calling this function will perform the following pipeline on the given collection:

1.  Aggregate to a temporary collection
2.  Perform MapReduce on the temporary collection.
3.  Dispose the temporary collection

Sidenote: this module uses [tempcol](https://github.com/tounano/tempcol), which handles the removal of collections even
on cases of errors.

Temporary collections would be prefixed as `tmp.ar`.

#### args

*  `collection` - The collection to perform Aggregate/Reduce on.
*  `pipelineArray` - as you would do with the aggregation framework.
*  `map` - map function, as you would do with `mapReduce`.
*  `reduce` - reduce function, as you would do with `mapReduce`.
*  `options` - options object.

#### options

*  All options that are supported in the aggregation framework, except of `out`.
*  All options that are supported in `mapReduce`
*  `ttl` - abort after X amount of seconds. (default=3600).

####Example

You can run the following example several times, it will reduce the results to `tstReduce` collection incrementally.

```js
var MongoClient = require('mongodb').MongoClient;
var aggregateReduce = require('aggregate-reduce');

MongoClient.connect('YOUR MONGO URI',{}, function (err, db) {
  if (err) return console.error(err);

  // Let's create a test data set and insert 1K rows
  var col = db.collection('test');
  var timeStamp = new Date().getTime();

  var i = 0;

  ;(function insert(){
    var d = new Date(2014, Math.round(Math.random() * 11 +1), Math.round(Math.random() * 30 +1))
    var obj = {
      date: d,
      rand: Math.round(Math.random()*100),
      timestamp: timeStamp
    }

    col.insert(obj, function (err) {
      if (err) {console.error(err); return db.close();}
      console.log('inserted', obj)

      if (++i < 1000) return insert();

      console.log('done');
      var map = function () {emit(this._id, this)};
      var reduce = function (key, values) {
        var obj = values[0];
        for (var i=1; i<values.length; ++i) {
          obj.count = (obj.count || 0) + values[i].count;
          obj.sum = (obj.sum || 0) + values[i].sum;
        }
        return obj;
      }

      aggregateReduce(col,[
        {$match: {timestamp:{$gte: timeStamp}}},
        {$group:{
          _id:{month:{$month: '$date'}, day:{$dayOfMonth:'$date'}},
          count: {$sum: 1},
          sum: {$sum: '$rand'}
        }}
      ],map, reduce, {out:{reduce: 'tstReduce'}}, function (err, col) {
        if(err) return console.error(err);
        col.find().stream().on('data', console.log);
      })
    })
  })();
});
```

## install

With [npm](https://npmjs.org) do:

```
npm install aggregate-reduce
```

## license

MIT

repository: tounano/aggregate-reduce

repo_name: tounano/aggregate-reduce


text:
# Open Reproducible Electron Microscopy Data Analysis (OREMDA)

The OREMDA project is developing an open source platform for the analysis and visualization of electron microcopy data sets. We are leveraging container technologies to encapsulate processing into scalable, reproducible pipelines.

<img src="https://github.com/OpenChemistry/oremda/blob/master/docs/images/peak.png?raw=true" >

The OREMDA project is funded by DOE Office of Science contract DE-SC0021601.

Contributing
------------

Our project uses GitHub for code review, please fork the project and make a
pull request if you would like us to consider your patch for inclusion.

![Kitware, Inc.][KitwareLogo]

  [KitwareLogo]: http://www.kitware.com/img/small_logo_over.png "Kitware"

repository: live-long-and-prosper/oremda

repo_name: live-long-and-prosper/oremda


text:
---
layout: default
---

# 1995-09-21 - Re: Is the book Network Security any good?

## Header Data

From<EMAIL_ADDRESS>(Hallam@w3.org)

To<EMAIL_ADDRESS>Message Hash: bfcfaa392e2be2d366096c800d934991a558dc56a6d07612c270e0ffe13b0ac6

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-09-21 00:18:04 UTC

Raw Date: Wed, 20 Sep 95 17:18:04 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS><EMAIL_ADDRESS>Date: Wed, 20 Sep 95 17:18:04 PDT
To<EMAIL_ADDRESS>Subject: Re: Is the book Network Security any good?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Date: Wed, 30 Aug 95 22:53:49 -0400
From<EMAIL_ADDRESS>

>Has anyone read the book "Network Security Private Communication in a
>PUBLIC World" yet?  It's by Charlie Kaufman, Radia Perlman, and Mike
>Speciner, and has a copyright date of this year.

Its pretty good on security and structure of protocols. Makes a good companion
the Schneier book. I use it frequently.

It does have some very irritating assertions concerning ASN.1 however,
specifically concerning its use in Kerberos. I consider Kerberos's use of ASN.1
to be far superior than the alternative suggested which is pure lossage.
Lambasting the use of ASN.1 is fair game but arguments over wasted bytes miss t
point of ASN.1 and the BER encoding entirely.

It would make a usefull course book.

        Phill

{% endraw %}
```

## Thread

+ Return to [September 1995](/archive/1995/09)

+ Return to<EMAIL_ADDRESS>(Hallam@w3.org)](/authors/hallam_at_w3_org_hallam_at_w3_org_)"

+ 1995-09-21 (Wed, 20 Sep 95 17:18:04 PDT) - Re: Is the book Network Security any good? -<EMAIL_ADDRESS>(Hallam@w3.org)_


text:
# Spring Boot API with React UI

This example app shows how to create a Spring Boot API and display its data with a React UI.

To run the server, cd into the `server` folder and run `./mvnw spring-boot:run`.

To run the client, cd into the `client` folder and run `yarn && yarn start`.

repository: lukeddy/spring-boot-react-example

repo_name: lukeddy/spring-boot-react-example


text:
# OMS' website [![Build Status](https://travis-ci.org/oslomarketsolutions/website.svg?branch=master)](https://travis-ci.org/oslomarketsolutions/website)

It follows the [JAMstack architecture](https://jamstack.org) by using Git as a single source of truth, and [Netlify](https://www.netlify.com) for continuous deployment, and CDN distribution.

## Access Locally

You need to set an environment variable to use fontawesome pro.
Contact OMS to get the token.

```
export FONTAWESOME_TOKEN="00000000-0000-0000-0000-000000000000"
```

```
$ nvm install
$ yarn
$ yarn develop
```

To test the CMS locally, you'll need run a production build of the site:

```
$ nvm install
$ yarn build
$ yarn serve
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first to
discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

Everything in this repository except the OMS logo is MIT licensed.

All rights are reserved for the OMS logo.

repository: oslomarketsolutions/website

repo_name: oslomarketsolutions/website


text:
# WASM test

This repository contains a Go application for the browser. The app is built with
`GOOS=js GOARCH=wasm` and can be run on Edge, Chrome & Firefox. It is able to update
the HTML using Go template library, enabling Go developper to share logic between
frontend and backend. :tada:

There is also a server app, serving files from disk. The client
and the server can be run using `make run`.

repository: aitva/wasm-test

repo_name: aitva/wasm-test


text:
# Laravel 5 url shortener

[![Total Downloads](https://img.shields.io/packagist/dt/waavi/url-shortener.svg?style=flat-square)](https://packagist.org/packages/djordjevicmladen/url-shortener)

## Introduction

URL shortener package that gives a convenient Laravel Facade for [mremi/UrlShortener](https://github.com/mremi/UrlShortener)

## Laravel compatibility

 Laravel  | translation
:---------|:----------
 5.1.x    | 1.0.x
 5.2.x    | 1.0.1 and higher
 5.5.x    | 1.0.7 and higher
 5.8.x    | 2.0 and higher

## Installation and Setup

Require through composer

    composer require djordjevicmladen/url-shortener

Or manually edit your composer.json file:

    "require": {
        djordjevicmladen/url-shortener": "^2.0"
    }

In config/app.php, add the following entry to the end of the providers array:

    Abstractrs\UrlShortener\UrlShortenerServiceProvider::class,

And the following alias:

    'UrlShortener' => Abstractrs\UrlShortener\Facades\UrlShortener::class,

Publish the configuration file, the form view and the language entries:

    php artisan vendor:publish --provider="Abstractrs\UrlShortener\UrlShortenerServiceProvider"

Check the config files for the environment variables you need to set for the selected driver.

## Usage

### Shorten a url

    ```php
    \UrlShortener::shorten('http://google.com'); // Uses default driver as per config settings
    \UrlShortener::driver('bitly')->shorten('http://google.com');
    ```

### Expand a url

    ```php
    \UrlShortener::expand('http://google.com'); // Uses default driver as per config settings
    \UrlShortener::driver('bitly')->expand('http://google.com');
    ```

repository: djordjevicmladen/url-shortener

repo_name: djordjevicmladen/url-shortener


text:
# Training sessions for Cloud IoT module of INSA Telecom department

## Training sessions

1. [How to authenticate with AWS SSO to AWS Console?](docs/0_authentication/README.md)
1. [How to publish MQTT messages to AWS IoT Core/Analytics from my device](docs/1_publish_mqtt/README.md)
1. [How to extract temperature information in real time?](docs/2_temperature_extraction/README.md)
1. [How to visualize data with BI tool?](docs/3_visualization/README.md)
1. [How to monitor my service and receive alert if something goes wrong?](docs/_monitoring_alerting/README.md)
1. [How to use IoT Analytics Dataset to train a machine learning model?](docs/5_machine_learning/README.md)

## Mkdocs(Optional)
If you want to have a search bar, you can use `mkdocs``

```bash
mkdocs serve
```
this document can be accessed [http://<IP_ADDRESS>:8000/](http://<IP_ADDRESS>:8000/)

For more information: [https://www.mkdocs.org/](https://www.mkdocs.org/
)
## Folder hierarchy:
The code in this repo uses the following folder hierarchy:

```yaml
docs
└ training_session_name
  └ data/
  └ img/
  └ README.md
```

## Contributing:
### How to merge your feature request(Git flow):
[Git flow by Atlassian](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow)

### How to write your commit message(Commit Message Format):
[Commit Message Format by Angular](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#-commit-message-format)


text:
# CosyncJWTiOS

## License

This software is licensed under the Apache 2.0 open source license

http://www.apache.org/licenses/LICENSE-2.0

## Installation

iOS Sample App for CosyncJWT

On the Cosync portal

* create an application called CosynJWTiOS
* In the JWT tab/Metadata Fields section
* Select 'Automatically add email field to meta data with handle'.
* Add two meta data fields
* Path 'user_data.name.first' with field name 'firstName'
* Path 'user_data.name.last' with field name 'lastName'

On the MongoDB Atlas side

* Create a Free Atlas Cluster. Under 'Additional Settings' select version 'MongoDB 4.4'
* Name new Atlas Cluster CosyncJWTiOS
* Hit Create Cluster

Once the cluster has been created, select the Realm tab

* Select Create a New App
* Hit 'Start a new Realm App'
* Name the new Realm App 'CosyncJWTiOS'
* Link it to the CosyncJWTiOS cluster created above (default choice)
* Hit Create Realm Application

Set up Sync in Dev Mode

* Select Cluster to Sync 'CosyncJWTiOS'
* Define a Database called 'CosyncJWTiOS_DB'
* Create a partition key called '_partition' as a string
* Hit 'Turn Dev Mode On'

Set up user provider

* Copy the Realm Public Key for the Application from the Keys section in the CosyncJWT portal
* In the Realm app go to the User tab
* Select the Providers tab
* Select 'Custom JWT Authentication' and hit 'Edit'
* Toggle the Provider Enable control to on
* Select 'Signing Algorithm" as RS256
* Create a Signing Key called 'CosyncJWTiOSKey' and enter the Public Key copied above
* Add a metadata field with path "user_data.email' and with field name email
* Hit 'Save'

Deploy the Realm App

* Hit 'REVIEW & DEPLOY'

XCode Project

* Download the source code from Github

* Install CosyncJWTSwift using the Swift Package Manager

    https://github.com/Cosync/CosyncJWTSwift.git

    Leave the default value of Up to Next Major, then click Next.

    Select CosyncJWTSwift, then click Finish.

* Install Realm & RealmSwift using the Swift Package Manager

    https://github.com/realm/realm-cocoa.git

    Leave the default value of Up to Next Major, then click Next.

    Select both Realm and RealmSwift, then click Finish.

* Copy the Realm id from the top left button in the Realm panel in the web UI
* Edit the REALM_APP_ID in the Constants.swift function with the copied Realm Id
* Edit the APP_TOKEN in the Constants.swift function with the APP_TOKEN from the Cosync Portal

Run the app

repository: agape-apps/CosyncSamples

repo_name: agape-apps/CosyncSamples


text:
## `Q` and `Bluebird`
Before JS native promises were implemented in NodeJS, prehistoric people were using libraries such as `Q` and `Bluebird`.

`Q` (v1.5.0) uses `process.nextTick` queue to schedule callbacks for resolved/rejected promises.

On the other hands, `Bluebird` (v3.5.0) uses `setImmediate` by default to schedule promise callbacks in recent NodeJS versions

```javascript
const Q = require('q');
const BlueBird = require('bluebird');

Promise.resolve().then(() => console.log('native promise resolved'));
BlueBird.resolve().then(() => console.log('bluebird promise resolved'));
setImmediate(() => console.log('set immediate'));
Q.resolve().then(() => console.log('q promise resolved'));
process.nextTick(() => console.log('next tick'));
setTimeout(() => console.log('set timeout'), 0);
```

In the above example, `BlueBird.resolve().then` callback has the same semantics as the following `setImmediate` call. Therefore, bluebird’s callback is scheduled in the same immediates queue before the `setImmediate` callback. Since Q uses `process.nextTick` to schedule its resolve/reject callbacks, `Q.resolve().then` is scheduled in the nextTick queue before the succeeding `process.nextTick` callback. We can conclude our deductions by seeing the actual output of the above program, as follows:

```shell
q promise resolved
next tick
native promise resolved
set timeout
bluebird promise resolved
set immediate
```

> This behavior is identical for promise `reject` handlers as well.

repository: jafaryor/knowledge-base

repo_name: jafaryor/knowledge-base


text:
# Learn Push 2 with Svelte (and WebMIDI)

**🌸 Currently very early in development! Feel free to contribute <3 🌸**

Learn chords, scales, and music theory on the Push 2, right inside your web browser! This started as a project to test out Svelte but it turns out it's really useful 🤷♀

## Demo

**[View in any Chromium-based browser](https://greyivy.github.io/learn-push2-with-svelte)**

https://user-images.githubusercontent.com/5335625/122630992-7b3b2b80-d0b7-11eb-9c0d-1e01e7e6c60c.mp4

## Features
- Experimental Push 2 display driver with WebUSB and Pyodide (via WebASM)
- Works on Push 2 and Push 1 (without a working display driver at the moment)
- Highlights chords and scales onscreen and on your controller display and pads
- Overlays useful music theory information on top of your pads
- Mirrors the physical controller onscreen in real time
- Shows a traditional keyboard mapped to your controller's pads
- Predicts the chord you're currently playing
- Helps you practice chord progressions (think Guitar Hero)
- A few sounds and a TON of chords, chord progressions, and scales to try out
- Easy to add other controllers (e.g. Launchpad), layout generators, and sounds because TypeScript is awesome!
- Super performant thanks in part to to [Svelte's stores implementation](https://svelte.dev/tutorial/writable-stores) and its easy nesting

Thanks to [@stordahl](https://github.com/stordahl) for introducing me to Svelte!

## Roadmap
- UI improvements

### Future ideas/improvements
- Launchpad support
- Push 1 display support
- Song bank
- Drumming practice
- Fix chord equality (e.g. when advancing the chord bank)
- Rewrite display driver in Rust (or another language) w/ WebASM
- Configure a code formatter
- Real-time remote jam sessions through WebRTC!?
- ???
- No profit (donate to mutual aid or a trans organization near you instead!)

---

This is a project template for [Svelte](https://svelte.dev) apps. It lives at https://github.com/sveltejs/template.

To create a new project based on this template using [degit](https://github.com/Rich-Harris/degit):

```bash
npx degit sveltejs/template svelte-app
cd svelte-app
```

*Note that you will need to have [Node.js](https://nodejs.org) installed.*

## Get started

Install the dependencies...

```bash
cd svelte-app
npm install
```

...then start [Rollup](https://rollupjs.org):

```bash
npm run dev
```

Navigate to [localhost:5000](http://localhost:5000). You should see your app running. Edit a component file in `src`, save it, and reload the page to see your changes.

By default, the server will only respond to requests from localhost. To allow connections from other computers, edit the `sirv` commands in package.json to include the option `--host <IP_ADDRESS>`.

If you're using [Visual Studio Code](https://code.visualstudio.com/) we recommend installing the official extension [Svelte for VS Code](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode). If you are using other editors you may need to install a plugin in order to get syntax highlighting and intellisense.

## Building and running in production mode

To create an optimised version of the app:

```bash
npm run build
```

You can run the newly built app with `npm run start`. This uses [sirv](https://github.com/lukeed/sirv), which is included in your package.json's `dependencies` so that the app will work when you deploy to platforms like [Heroku](https://heroku.com).

## Single-page app mode

By default, sirv will only respond to requests that match files in `public`. This is to maximise compatibility with static fileservers, allowing you to deploy your app anywhere.

If you're building a single-page app (SPA) with multiple routes, sirv needs to be able to respond to requests for *any* path. You can make it so by editing the `"start"` command in package.json:

```js
"start": "sirv public --single"
```

## Using TypeScript

This template comes with a script to set up a TypeScript development environment, you can run it immediately after cloning the template with:

```bash
node scripts/setupTypeScript.js
```

Or remove the script via:

```bash
rm scripts/setupTypeScript.js
```

## Deploying to the web

### With [Vercel](https://vercel.com)

Install `vercel` if you haven't already:

```bash
npm install -g vercel
```

Then, from within your project folder:

```bash
cd public
vercel deploy --name my-project
```

### With [surge](https://surge.sh/)

Install `surge` if you haven't already:

```bash
npm install -g surge
```

Then, from within your project folder:

```bash
npm run build
surge public my-project.surge.sh
```

license: Unlicense


text:
# Get Edge

## Challenge

Write a function based on the specifications above, which takes in a graph, and an array of city names. Without utilizing any of the built-in methods available to your language, return whether the full trip is possible with direct flights, and how much it would cost.

## Approach & Efficiency

* Check if cities array or graph is empty, if so return {isPossible: fasle, cost: 0}.
* If not, define a toalcost variable and set it to 0.
* loop throgh the cities array except for the last city.
* Inside the for loop  get all the edges of this city.
* define foundCity variable and set it to false.
* Initiate an inner loop and compare each eadge with the name of next city. If found add edge weight to totalCost and foundCity to true.
* after the inner loop check if found city is false and if so return  {isPossible: fasle, cost: 0}.
*if the outer loop is finsihed that means all cities are found so return {isPossible: true, cost: totalCost}.

## Whiteboards

![fizzbuzztree](../../assets/getEdge.png)


text:
# utl_driving_distance_from_city_to_city_using_google_maps
Driving distance and time from city to city using google maps. Keywords: sas sql join merge big data analytics macros oracle teradata mysql sas communities stackoverflow statistics artificial inteligence AI Python R Java Javascript WPS Matlab SPSS Scala Perl C C# Excel MS Access JSON graphics maps NLP natural language processing machine learning igraph DOSUBL DOW loop stackoverfl SAS community.
    Driving distance from city to city using google maps

    https://developers.google.com/maps/documentation/javascript/usage

    "Most websites and applications may use the standard Google Maps JavaScript API free of charge.
    A project is restricted to the complimentary per-day-limit of 25,000 map loads, unless you enable billing on the project."

    You do not need a Google API for this but you can add an api key.

    github
    https://github.com/rogerjdeangelis/utl_driving_distance_from_city_to_city_using_google_maps

    SAS Forum
    https://tinyurl.com/ycfrjtzv
    https://communities.sas.com/t5/Base-SAS-Programming/SAS-Google-Maps-drive-distance-time-any-info-on-what-the/m-p/449060

    Doc on R and google maps
    https://cran.r-project.org/web/packages/gmapsdistance/README.html

    INPUT  Two macro variables
    ==========================

       %let origin="Washington+DC";
       %let destination="New+York+City+NY";

    PROCESS (working code)
    =======================

      results = gmapsdistance(origin = &origin, destination = &destination, mode = "driving");
      driving_miles=(results$Distance/1000)*.621371; * meters to miles;

    OUTPUT
    ======

     WORK.WANTWPS total obs=1

        DRIVING_
          MILES
         224.908

    *                _              _       _
     _ __ ___   __ _| | _____    __| | __ _| |_ __ _
    | '_ ` _ \ / _` | |/ / _ \  / _` |/ _` | __/ _` |
    | | | | | | (_| |   <  __/ | (_| | (_| | || (_| |
    |_| |_| |_|\__,_|_|\_\___|  \__,_|\__,_|\__\__,_|

    ;

    %let origin="Washington+DC";
    %let destination="New+York+City+NY";

    *          _       _   _
     ___  ___ | |_   _| |_(_) ___  _ __
    / __|/ _ \| | | | | __| |/ _ \| '_ \
    \__ \ (_) | | |_| | |_| | (_) | | | |
    |___/\___/|_|\__,_|\__|_|\___/|_| |_|

    ;

    %utl_submit_wps64('
    options set=R_HOME "C:/Program Files/R/R-3.3.2";
    libname wrk sas7bdat "%sysfunc(pathname(work))";
    proc r;
    submit;
    source("C:/Program Files/R/R-3.3.2/etc/Rprofile.site", echo=T);
    library(gmapsdistance);
    results = gmapsdistance(origin = &origin,
       destination = &destination,
       mode = "driving");
    results;
    driving_miles=(results$Distance/1000)*.621371;
    endsubmit;
    import r=driving_miles data=wrk.wantwps;
    run;quit;
    ');

    > source("C:/Program Files/R/R-3.3.2/etc/Rprofile.site", echo=T)
    > .libPaths(c(.libPaths(), "d:/3.3.2", "d:/3.3.2_usr"))
    > options(help_type = "html")
    > library(gmapsdistance)
    > results = gmapsdistance(origin = "Washington+DC",   destination = "New+York+City+NY",   mode = "driving")
    > results
    > driving_miles=(results$Distance/1000)*.621371

    NOTE: Processing of R statements complete

    11        import r=driving_miles data=wrk.wantwps;
    NOTE: Creating data set 'WRK.wantwps' from R data frame 'driving_miles'
    NOTE: Column names modified during import of 'driving_miles'
    NOTE: Data set "WRK.wantwps" has 1 observation(s) and 1 variable(s)

    12        run;
    NOTE: Procedure r step took :
          real time : 1.450
          cpu time  : 0.046

    13        quit;


text:
# karma-osx-reporter

> Reporter using Mac OS 10.8+ Notification Center to display results.

![image](http://f.cl.ly/items/2T350d1c0H30460U3W2Y/Screen%20Shot%202013-08-06%20at%201.46.47%20PM.png)

Built on top of [node-osx-notifier] and based on [AvnerCohen's code].

Only works with **Karma 0.9 or later** which enables custom plugins.

For more information on Karma see the [homepage].

## Installation

1. Install Karma and karma-osx-reporter plugin.

  a. Globally. System-wide with `karma` available on command line.

    ```sh
    npm install -g karma
    npm install -g karma-osx-reporter
    ```

  b. Locally to your project (preferred). Simply run:

    ```sh
    npm install karma --save-dev
    npm install karma-osx-reporter --save-dev
    ```

    or add the dependencies to `package.json` manually and run `npm install`:

    ```js
    "devDependencies": {
      "karma": ">=0.9",
      "karma-osx-reporter": "*"
    }
    ```

    If you install locally, you'll need to run Karma using `node_modules/karma/bin/karma`.

  In any case, the plugin needs to be installed as a peer dependency to Karma (i.e. in the sibling folder). This just means you cannot use global Karma with local plugins or vice-versa.

2. Add it as a reporter in the config file

  ```js
  reporters: ['progress', 'osx']
  ```

  or pass through the command line

  ```sh
  $ karma start --reporters=progress,osx karma.conf.js
  ```

## Configuration

OSX Notifier runs on localhost:1337 by default. If you need to change that, simply override it in the config.

```js
config.set({
  ...

  osxReporter: {
    host: "localhost",
    port: 1337
  }

  ...
});
```

Any additional parameter will be passed to [node-osx-notifier](https://github.com/azoff/node-osx-notifier). Check the documentation for details. Some examples:

```js
config.set({
  osxReporter: {
    activate: 'com.apple.Terminal',
    open: 'http://google.com',
    execute: 'open .'
  }
});
```

To decide dynamically what to pass into these options, define them as functions:

```js
config.set({
  osxReporter: {
    activate: function(results, browser) {
      return results.failed > 0 ? 'com.apple.Terminal' : 'com.apple.Safari';
    }
  }
});
```

## License

MIT License

[node-osx-notifier]: https://github.com/azoff/node-osx-notifier
[AvnerCohen's code]: https://github.com/karma-runner/karma/commit/ffd48a7f9aa7bc9a27516393d4d592edc6b628f7
[homepage]: http://karma-runner.github.io

repository: royriojas/angular-experiments

repo_name: royriojas/angular-experiments


text:
angular-django-formset
======================

[![Build Status](https://travis-ci.org/hilios/angular-django-formsets.png?branch=master)](https://travis-ci.org/hilios/angular-django-formsets)

A set of AngularJS directives to easily manage Django Formsets (add and remove) into front-end.

## Usage

Add the `ngDjangoFormset` module to your Angular application:

```
angular.module('app', ['ngDjangoFormset']);
```

Given you have a template with local variable `formset` that is an instance of `BaseFormSet` (usualy created by the factory `formset_factory`):

```html
<form method="post">{% csrf_token %}
  <div formset="template.html">
    {{formset.management_form}}
    <div formset-container>
      {% for form in formset %}
      <div formset-child>
        {{form.as_p}}
        <button formset-remove>Remove</button>
      </div>
      {% endfor %}
    </div>
    <button formset-add>Add</button>
  </div>
  <button type="submit">Submit</button>
</form>
<!-- template.html -->
{% with form=formset.empty_form %}
<script type="text/ng-template" id="template.html">
<div formset-child>
  {{form.as_p}}
  <button formset-remove>Remove</button>
</div>
</script>
{% endwith %}
```

## Bult-in directives

```
formset="{template}.html"
formset-child
formset-add
formset-remove

# Modifiers
formset-prefix
formset-can-delete
formset-can-order
```

## Python

Given the django formset:

```python
from django import forms
from django.shortcuts import render, redirect
from django.forms.formsets import formset_factory

class SimpleForm(forms.Form):
    name = forms.CharField()
    email = forms.EmailField()

SimpleFormSet = formset_factory(SimpleForm, extra=2, can_delete=True)

def main(request):
    formset = SimpleFormSet(request.POST or None, prefix="foo")

    if form.is_valid() and formset.is_valid():
        return redirect('/')

    return render(request, 'template.html', {'formset': formset})
```

repository: danirus/angular-django-formsets

repo_name: danirus/angular-django-formsets


text:
# ApplePayApi
> squareconnect.apis.apple_pay_api

All endpoints are relative to [Square Connect V2 Documentation](https://docs.connect.squareup.com/api/connect/v2/#navsection-endpoints)

Method | HTTP request
------------- | -------------
[**register_domain**](ApplePayApi.md#register_domain) | **POST** /v2/apple-pay/domains

# **register_domain**
> RegisterDomainResponse register_domain(body)

### Description

Activates a domain for use with Web Apple Pay and Square. A validation will be performed on this domain by Apple to ensure is it properly set up as an Apple Pay enabled domain.  This endpoint provides an easy way for platform developers to bulk activate Web Apple Pay with Square for merchants using their platform.  To learn more about Apple Pay on Web see the Apple Pay section in the [Embedding the Square Payment Form](/payment-form/add-digital-wallets/apple-pay) guide.

### Parameters

Name | Type | Notes | Default Value
------------- | ------------- | ------------- | -------------
 **body** | [**RegisterDomainRequest**](RegisterDomainRequest.md)|

### Return type

[**RegisterDomainResponse**](RegisterDomainResponse.md)

### Authorization

Assign your **Access Token** from developer portal to the authorization parameter.

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

repository: square/connect-python-sdk

gha_language: Python

repo_name: square/connect-python-sdk


text:
# Garuda

Garuda is a Web-UI based automated machine learning (Auto-ML) platform. The main goal of the tool is to provide an easy-to-use and less puzzling way to build, optimize, and deploy machine learning models for any problem domain. This tool was originally developed for synthetic biology applications. It gives an access for non machine learning experts; with no programming background, to work with a variety built-in machine learning models to solve a problem of their own, and/or machine learning experts to automate the repetitive works in building and experimenting the modeling process, so that they can focus on what matters most (i.e. feature engineering, EDA. etc.)

At this point, machine learning algorithms supported by Garuda are primarily based on some of the most popular Python machine learning libraries, such as: scikit-learn, xgboost, light-gbm, and keras/tensor-flow. The back-end server is built on top of Flask, and the front-end UI is built with Bootstrap/jQuery.

This is an on-going work that I update regularly. I am committed to release the software as an open-source, and I can always use some help from contributors who are passionate in developing tools that will provide access machine learning for everyone.

## Demo

Click the following video links to see Garuda in action.

[Garuda Demo #1 - Microfluidics Design Automation](https://youtu.be/5QMasGs92oE)

[Garuda Demo #2 - Genetic Parts Prediction (Cello Data)](https://youtu.be/LSQdfTWk1Tw)

## Screenshot

![Model training page (home-page)](https://github.com/rmardian/garuda-flask/blob/master/screenshot/01.png)
![Data overview](https://github.com/rmardian/garuda-flask/blob/master/screenshot/02.png)
![Training results](https://github.com/rmardian/garuda-flask/blob/master/screenshot/03.png)
![Model prediction page](https://github.com/rmardian/garuda-flask/blob/master/screenshot/04.png)
![Prediction results](https://github.com/rmardian/garuda-flask/blob/master/screenshot/05.png)

repository: rmardian/garuda-flask

repo_name: rmardian/garuda-flask


text:
# ModelExample

## Demonstrates

* Hooks
* Installing tables for a model
* Models
* ModelTables
* ModelTable::findBy()
* ModelTable::applySearchFilters

The plugin creates a simple use case of wanting a Collector class to say more about the origins of a collection (not the 'collectors' info already in Omeka that refers to users in Omeka. It creates a couple new fake collections, and a handful of Collector objects and saves them to the database. One of the three Collectors is has public property set to FALSE.

repository: omeka/TrainingMaterials

repo_name: omeka/TrainingMaterials


text:
# SeedGen
An over-engineered seed generator

A seed is generated from the computer's name, os version, processor count, tick count, user name and the previous seed.

Usage:

```csharp
int Seed = SeedGen.Main.GenSeed();
```


text:
+++

categories="article"
date="2022-12-14T00:24:00+03:00"
issue="2022-04"
issue_name="2022 - #04"
issue_id="4"
number="01"
file="https://static.nuclear-power-engineering.ru/articles/2022/04/01.pdf"
first_page="5"
last_page="18"
udc="621.039.574.5"
title="Heavy-Water Thorium-Uranium Thermal-Neutron Breeder Reactor"
original_title="Тяжеловодный уран-ториевый реактор-размножитель на тепловых нейтронах"
authors=["IsanovKA", "EgorovMYu"]
tags=["thorium uranium fuel cycle", "breeding", "thermal breeder reactor", "protactinium pit", "breeding ratio", "nuclide composition change", "fuel production"]
rubric = "physicsandtechnology"
rubric_name = "Physics and technology of nuclear reactors"
outputs=["HTML", "DOI"]
doi="https://doi.org/10.26583/npe.2022.4.01"

+++

The problem of the natural uranium reserve depletion and further transition to a uranium thorium fuel cycle are analyzed.
Breeding options and breeder reactor versions are presented.

A concept is proposed and considered for a thorium uranium thermal neutron breeder reactor.
The thermal breeder design philosophy is described.
A neutronic calculation of an infinite fuel assembly model has been undertaken.
The FA layout has been optimized.

The effective multiplication factor and the breeding ratio, as well as the active spectrum have been determined by multigroup method. The peculiarities of the nuclide composition change, inherent in a thorium uranium fuel cycle, are considered.
The protactinium effect is discussed.

The change in the nuclide composition for a two year life (720 effective days) has been simulated.
The lifetime change in the effective multiplication factor and the breeding ratio has been determined.

Prospects for the thorium uranium breeder implementation have been formulated. A thorium uranium thermal neutron breeder and fuel breeding have been shown to be feasible.

### References

1. Uranium 2020: Resources, production and demand: Technical report (2020) Nuclear nergy Agency Organisation for Economic Co-Operation and Development Available at:
https://oecd-nea.org/upload/docs/application/pdf/2020 (accessed Jul. 02, 2022).
2. Zverev D.L., Samoilov O.B., Romanov A.I., Panov V.A., Fal’kov A.A., Sholin E.V. & Zotov
S.A. Fuel for VVER and PWR: Current Status and Prospects. Atomic Energy. 2020, v. 129,
iss. 2, pp. 51-53; DOI: https://doi.org/10.1007/s10512-021-00720-z .
3. Calculation of the Isotopic Composition, Crossections and Fluxes for a Typical PWR-Cell
Loaded with (PU-Th) O 2 -Fuel, as a Function оf the Fuel Burnup. IAEA Report, 1996.
4. Marshalkin V.E., Povyshev V.M. Breeding of 233 U in a Thorium-Uranium Fuel Cycle in
VVER Reactors Employing Heavy Water. VANT. Ser. Yadernye i Reaktornye Konstanty.
2013, iss. 2, pp. 12-29 (in Russian).
5. Marshalkin V.E., Povyshev V.M. Utilization of Non-Weapon Plutonium and High-
Enriched Uranium with 233 U Isotope Production in VVER Type Reactors Using Thorium and
Heavy Water. VANT. Ser. Yadernye i Reaktornye Konstanty. 2014, iss. 3, pp. 42-60 (in
Russian).
6. Yurova L.N., Polyakov А.А., Rukhlo V.P., Titarenko Yu.E. & Bobrov S.A. Investigation
into the Possibilities of 233 U Accumulation in the VVER Type Reactors at Minimal
Production of 232 U. Soviet Atomic Energy. 1978, v. 45, pp. 674-678; DOI: https://doi.org/
10.1007/BF01120588 .
7. Marshalkin V.E. The Concept of Closed Thorium-Uranium-Plutonium Fuel Cycle in
Nuclear Power Industry. VANT. Ser. Yadernye i Reaktornye Konstanty. 2018, iss. 4, pp. 5-
28 (in Russian).
8. Marshalkin V.E., Povyshev V.M. The Expediency of Using Excess Amounts of Weapons-
Grade Uranium and Plutonium and Power-Grade Plutonium to Transfer Thermal Reactors
to a Closed Thorium-Uranium Fuel Cycle. VANT. Ser. Yadernye i Reaktornye Konstanty.
2019, iss. 4, pp. 43-60 (in Russian)
9. Reda S.M., Gomaa I.M., Bashter I.I., Amin E.A. Neutronic Performance of the VVER-1000
Reactor Using Thorium Fuel with ENDF Library. Science and Technology of Nuclear
Installations. 2021, v. 4, pp. 1-9; DOI: https://doi.org/10.1155/2021/8838097 .
10. Marshalkin V.E., Povyshev V.M. Breeding of 233 U in the Thorium-Uranium Fuel Cycle in
VVER Reactor Using Heavy Water. Physics of Atomic Nuclei. 2015, v. 78, no. 11, pp. 1274-
1286; DOI: https://doi.org/10.1134/S1063778815110113 .
11. Marshalkin V.E., Povyshev V.M. Method of Operating Nuclear Reactor in Thorium Fuel
Cycle with Production of Uranium Isotope 233 U. Izobreteniya. Poleznye Modeli. 2015, no.
5, pp. 1-20. – Pat. 2541516 RF (in Russian).
12. Marshalkin V.E., Povyshev V.M. Utilization of Non-Weapons-Grade Plutonium and
Highly Uranium with Breeding of the 233 U Isotope in the VVER Reactors Using Thorium and
Heavy Water. Physics of Atomic Nuclei. 2015, v. 78, no. 11, pp. 1287-1300; DOI: https://
doi.org/10.1134/S1063778815110125 .
13. Marshalkin V.E., Povyshev V.M. Method of Operating a Nuclear Reactor in the
Uranium-Thorium Fuel Cycle with the Production of the 233 U Isotope. Izobreteniya.
Poleznye Modeli. 2017, no.14, pp. 1-20. Pat. 2619599 RF (in Russian).
14. Marshalkin V.E., Povyshev V.M. On the Equilibrium Isotopic Composition of the
Thorium-Uranium-Plutonium Fuel Cycle. Physics of Atomic Nuclei. 2016, v. 79, no. 8, pp.
1290-1297; DOI: https://doi.org/10.1134/S1063778816080135 .
15. Ponomarev-Stepnoj N.N., Lunin G.L., Ryazantsev E.P., Morozov A.G., Kuznetsov V.V.,
Kevrolev V.V. & Kuznetsov V.F. Light-Water Thorium Reactor VVER-T. Atomic Energy.
1998, v. 85, pp. 685-699; DOI: https://doi.org/10.1007/BF02368690 .
16. Marshalkin V.E., Povyshev V.M. Natural Transmutation of Actinides by the Fission
Reaction in the Closed Thorium-Uranium-Plutonium Fuel Cycle. VANT. Ser. Yadernye i
Reaktornye Konstanty. 2016, iss. 4, pp. 64-75 (in Russian).
17. Marshalkin V.E., Povyshev V.M. The Second-Generation Fissile Materials in Nuclear
Power Industry. VANT. Ser. Yadernye i Reaktornye Konstanty. 2017, iss. 4, pp. 54-75 (in
Russian).
18. Marshalkin V.E., Povyshev V.M. Method of Operating a Nuclear Reactor in the Thorium Fuel Cycle with the Production of the Uranium Isotope 233 U. Izobreteniya. Poleznye
Modeli. 2017, no. 31, pp. 1-20. Pat. 2634476 RF (in Russian).
19. Alvarez R. Thorium Reactors: Their Backers Overstate the Benefits. Nuclear
Information and Resource Service. 2014. Available at: https://www.nirs.org/wp-
content/uploads/factsheets/th. (accessed Jul. 02, 2022).
20. Thorium-Based Nuclear Fuel: Current Status and Perspectives. Vienna: IAEA, 1987,
164 p. (IAEA-TECDOC-412). Available at: https://inis.iaea.org/collection/
NCLCollectionStore/ (accessed Jul. 02, 2022).
21. Abagyan L.P., Bazazyanc N.O., Nikolaev M.N., Cibulya A.M. Group Constants for the
Calculation of Reactors and Protection. Moscow. Energoizdat Publ., 1981, 232 p. (in
Russian).
22. Manturov G.N., Nikolaev M.N., Tsibulya A.M. System of Group Constants BNAB-93. Part
1. Nuclear Constants for Calculation of Neutron and Photon Radiation Fields. VANT. Ser.
Yadernye i Reaktornye Konstanty. 1996, iss. 1, p. 59 (in Russian).
23. Shamanin I.V., Chertkov Yu.B., Bedenko S.V. Thorium-loaded Low-Power Reactor
Installation Operated with Super-Long Fuel Residence Time. Izvestiya vuzov. Yadernaya
Energetika. 2016, no. 2, pp. 121-132. DOI: https://doi.org/10.26583/npe.2016.2.12
(in Russian).
24. Sylvain D., Elisabeth H., Herve N. Thorium-Uranium Nuclear Fuel Cycle. Euro Physics
News. 2007, v. 38, no. 2, pp. 24-27; DOI: https://doi.org/10.1051/EPN:2007007 .

branch_name: refs/heads/develop

gha_language: HTML


text:
# **OpenAg - Complete Guide for the Foodcomputer Project**
--------------------------------------------------
:cloud: :computer: :movie_camera:  :sunny: :potable_water: :cherries: :sweet_potato: :corn: :tomato: :pineapple: :grapes: :lemon: :apple: :peach: :pear: :green_apple: :tangerine: :cloud:

This document walks you through with the complete procedure on how to build a Food Computer from Scratch.

#
Hardware Build

* [Building the Food Computer Device](./HardwareFabrication.md)

#
Software Development

* [Software Installation Guide](./SoftwareInstallation.md)

#
Issues Faced and Solutions

* [Troubleshooting Mechanisms](./IssueTroubleShooting.md)

Some of the Images captured during our building process-

Integration of power module on to the frame
![Build Food Computer](https://github.com/SachinPawaskarUNO/mav-openag-foodcomputer2.0/blob/master/images/build/FC20-1.jpg)
Initial Build-
![Picture2](https://github.com/SachinPawaskarUNO/mav-openag-foodcomputer2.0/blob/master/images/build/FC20-3.jpg)
Jay building the Brain Module-
![Picture3](https://github.com/SachinPawaskarUNO/mav-openag-foodcomputer2.0/blob/master/images/build/FC20-20.jpg)
The Brain Module-
![Picture4](https://github.com/SachinPawaskarUNO/mav-openag-foodcomputer2.0/blob/master/images/build/FC20-15.jpg)
Fabrication of all the modules to the Frame-
![Picture5](https://github.com/SachinPawaskarUNO/mav-openag-foodcomputer2.0/blob/master/images/build/FC20-24.jpg)


text:
# Running the All Aragon Devs call

## Step 1. Create draft notes file for the next call
Note: After the first All Aragon Devs call, this step should be performed right after the call.

Create a new [hackmd](https://hackmd.io) document titled “All Aragon Devs #X”, with the number of the call.

- Use the [notes template](template.md) and add the agenda to the "Agenda" section.
- Set both read and write permissions to "public", and add a link to this document to the matching calendar event
- Send this document to established teams or members to allow them to add their own agenda items directly

Create another hackmd document, this one titled “All Aragon Devs #X (agenda)”, with the number of the call.

- Use the [public agenda template](public_agenda.md) and add the agenda to the "Agenda" section.
- Set both read and write permissions to "owner"
- Publish the document on hackmd, and use this link when publicly sharing the agenda

## Step 2. Review proposed agenda items

- Check alldevs email address throughout the week for proposed agenda items. Review proposed items and respond with [accepted](all_devs_accepted.md) or [rejected](all_devs_rejected.md) templates.
- Add approved agenda items to the documents above, and add the email addresses of the proposers to the matching calendar event.

## Step 3. Prepare for the livestream

Open Youtube with the Aragon account and copy the Livestream key.

  - Creator Studio -> Livestreaming -> Stream now -> Stream name/key.

## Step 4. Running the livestream

Open designated [Jitsi](https://meet.jit.si) channel (currently [aragondev](https://meet.jit.si/aragondev)), and paste the notes hackmd document.

Start livestream in Jitsi when the meeting is scheduled to start.

  - More actions menu button -> Start livestream

Welcome viewers and participants on the call. “Before we begin..” Designate a note taker if one has not volunteered already. Tell everyone on the call that a link to the notes is in the Jitsi chat, and anyone is welcome to add notes as well.

  - Document meeting attendees, agenda items, notes from discussions.

Do roll call and introduce anyone new to the call.

Run through each agenda item and pass to item owner to lead. Conclude each item discussion by repeating and documenting action items.

Keep meeting running on time. The goal is to have all agenda items addressed by the scheduled end time.

If all agenda items are covered before the scheduled end time, the meeting is done early.

Thank participants and viewers for attending, then stop the livestream.

## Step 5. Post-livestream follow-up

Under `/docs/videos/meeting_notes/all_aragon_devs`, create a notes file titled “alldevs[date].md”, with the date of the next call in `YYYYMMDD` format e.g. `alldevs20181008.md`.

Copy + paste the notes and video recording link to the notes document. Polish and fill out any remaining empty sections accordingly.

Update the `mkdocs.yml` file of the wiki with a relative link to the file under the Videos > Meetings > All Aragon Devs > Meeting notes section.

Go into the YouTube Creator Studio > Video Manager > Videos, click the arrow button next to the call video, and click "Download MP4". Upload the video file to the Aragon Association cloud storage instance for backup.

Go to Step 1 and create the agenda for the next call.

repository: serejandmyself/aragon-wiki

repo_name: serejandmyself/aragon-wiki


text:
NSUnit
======

NSUnit is a unit testing framework for Objective-C projects. NSUnit builds on top of SenTestingKit and provides a more Objective-C friendly API, particularly for testing against Foundation classes.

The Assert Class
----------------

The Assert class is the main test entry point to NSUnit. Tests are generally in the form:

     [Assert that:<subject> <verb>:<condition>]

Some examples:

     [Assert that:name isNot:[AnEmpty string]];
     [Assert that:name isNot:[Equal to:@"Omar"]];
     [Assert that:name is:[Equal to:"McNulty"]];
     [Assert that:someArrayOfInts areAll:[Less than:@20]];

Handling primitives with the The article
----------------------------------------
Primitive types such as doubles and ints can be automatically converted to their appropriate NSObject type using the The article.

Some examples:

     [Assert that:[The int:i] is:[Equal to:@25]];
     [Assert that:[The double:d] is:[Less than:@10]];

Ensuring Failure
----------------

NSUnit's Assert class provides a method for ensuring test failures. The fails:(void (^)(void)) method ensures that the supplied block raises an exception. For example

    [Assert fails:^{
        [WebService connectToUrl:nil];
    }];

Verbs
-----

The following verbs are available:

    is - The condition evaluates to true.
    isNot - The condition evaluates to false.
    areAll - Each value in the provided collection evaluates to true.
    areAllNot - Each value in the provided collection evaluates to false.

Conditions
----------

The following conditions are available:

    Equal to: - The subject equals the provided value.

    TheSame as: - The subject is the exact same object as the provided value.

    Less than: - The subject is less than the provided value. Both values must be non-nil numbers.
    Less thanOrEqual: - The subject is less than or equal to the provided value. Both values must be non-nil numbers.

    Greater than: - The subject is greater than the provided value. Both values must be non-nil numbers.
    Greater thanOrEqual: - The subject is greater than or equal to the provided value. Both values must be non-nil numbers.

    Between low: and: - The subject is a number between the two provided values, inclusive. All values must be non-nil numbers.

    AnEmpty array: - The subject is an empty array.
    AnEmpty string: - The subject is an empty string.

More examples can be found in NSUnit's [unit tests](https://github.com/jacksonh/NSUnit/blob/master/NSUnitTests/NSUnitTests.m).

Building
--------

NSUnit is available on CocoaPods

repository: jmcota/NSUnit

repo_name: jmcota/NSUnit


text:
use linux like system please

use `sudo apt-get install g++` to set up environment.

choose your favorite editor and other tools like debug tools.

then let's compile it and run
```
# compile to binary
g++ helloworld.cpp -o hello.o

# compile to assembler code
g++ helloworld.cpp -s hello.s

# make assembler code to binary
g++ hello.s -o hello.o

# run
./hello.o
```


text:
---
layout: default
---

# 1998-12-12 - Re: CFS & TCFS (was Re: Linux Encrypted File System)

## Header Data

From: Michael Hohensee<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: a040e615f7ff8f24652693950733bee7fb293295b39a965bb9c7453a371ce75d

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1998-12-12 18:28:40 UTC

Raw Date: Sun, 13 Dec 1998 02:28:40 +0800

## Raw message

```
{% raw  %}From: Michael Hohensee<EMAIL_ADDRESS>Date: Sun, 13 Dec 1998 02:28:40 +0800
To<EMAIL_ADDRESS>Subject: Re: CFS & TCFS (was Re: Linux Encrypted File System)
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

These are just NFS servers.  Do there exist any programs which actually
keep the contents of the filesystem on your hard-drive encrypted?

mib wrote:
>
> If you are running Red Hat Linux and want the Cryptographic File System (also
> available for most BSD-derived Unix systems and most current Linux releases),
> go to http://www.replay.com/redhat/cfs.html
>
> If you are running Linux 2.0.X and want the Transparent Cryptographic File
> System (improves on Matt Blaze's CFS, they say), go to
> http://vales.uni.net/tcfs/
>
> - d.

{% endraw %}
```

## Thread

+ Return to [December 1998](/archive/1998/12)

+ Return to "[mib <mib@io.com>](/authors/mib_mib_at_io_com_)"
+ Return to "[Michael Hohensee <michael@sparta.mainstream.net>](/authors/michael_hohensee_michael_at_sparta_mainstream_net_)"

+ 1998-12-12 (Sat, 12 Dec 1998 23:45:49 +0800) - [CFS & TCFS (was Re: Linux Encrypted File System)](/archive/1998/12/449206c75d8e2405c563771827d5fad4663bb5ed7a4245f46350e97010bf77d0) - _mib<EMAIL_ADDRESS>  + 1998-12-12 (Sun, 13 Dec 1998 02:28:40 +0800) - Re: CFS & TCFS (was Re: Linux Encrypted File System) - _Michael Hohensee<EMAIL_ADDRESS>  + 1998-12-12 (Sun, 13 Dec 1998 03:35:49 +0800) - [Re: CFS & TCFS](/archive/1998/12/fa896a6b78b803e423d7dbaf9823e84a5185f1d39579f73957953b83010aa08e) - _mib<EMAIL_ADDRESS>  + 1998-12-12 (Sun, 13 Dec 1998 03:44:13 +0800) - [Re: CFS & TCFS](/archive/1998/12/969decd198ad950bb72f502c1dc8b673dc1049b73c85cdf7fc66482141dc59ab) - _Michael Hohensee<EMAIL_ADDRESS>


text:
This repository will give access to new rules for the ESLint tool. You should use it only if you are developing a CommonJS application. It checks for require() function usage.

# Features
- Supports both `require()` and ES6 `import` syntax
- Supports aliases in webpack
- Supports different file extensions
- Works in Atom with `linter-eslint` package

# Usage

1. Install `eslint-plugin-require-path-exists` as a dev-dependency:

    ```shell
    npm install --save-dev eslint-plugin-require-path-exists
    ```

2. Enable the plugin by adding it to your `.eslintrc`:

    ```yaml
    plugins:
      - require-path-exists
    ```
3. You can also configure these rules in your `.eslintrc`. All rules defined in this plugin have to be prefixed by 'require-path-exists/'

    ```yaml
    plugins:
      - require-path-exists
    rules:
      - require-path-exists/exists: 2
      - require-path-exists/not_empty: 2
      - require-path-exists/too_many_arguments: 2
    ```

# Rules

| Name  | Description | Default Configuration |
| ------------- | ------------- | ------------- |
| exists  | You should only pass existent paths to require() | 'exists': 2 |
| not_empty | You should not call require() without arguments or with empty argument | 'not_empty': 2 |
| too_many_arguments | You should pass only one argument to require() function | 'too_many_arguments': 2 |

# ToDo

- Tests coverage.
- Check in different CommonJS environments (currently only tested in NodeJS and webpack).
- Remove dirty hack for Atom after [pull request](https://github.com/AtomLinter/linter-eslint/pull/89) in `linter-eslint` is merged.
- Think about more correct way to detect bundled NodeJS (and webpack) modules. Currently it is a constant array.

# License

MIT


text:
  @openhps/<%=projectName%>

    <a href="https://ci.mvdw-software.com/job/openhps-<%=projectName%>/" target="_blank">
        <img alt="Build Status" src="https://ci.mvdw-software.com/job/openhps-<%=projectName%>/job/dev/badge/icon">

    <a href="https://ci.mvdw-software.com/view/OpenHPS/job/openhps-<%=projectName%>/job/dev/lastCompletedBuild/testReport" target="_blank">
        <img alt="Tests" src="https://img.shields.io/jenkins/tests?compact_message&jobUrl=https%3A%2F%2Fci.mvdw-software.com%2Fview%2FOpenHPS%2Fjob%2Fopenhps-<%=projectName%>%2Fjob%2Fdev">

    <a href="https://ci.mvdw-software.com/view/OpenHPS/job/openhps-<%=projectName%>/job/dev/lastCompletedBuild/cobertura/" target="_blank">
        <img alt="Code coverage" src="https://img.shields.io/jenkins/coverage/cobertura?jobUrl=https%3A%2F%2Fci.mvdw-software.com%2Fview%2FOpenHPS%2Fjob%2Fopenhps-<%=projectName%>%2Fjob%2Fdev%2F">

    <a href="https://codeclimate.com/github/OpenHPS/openhps-<%=projectName%>/" target="_blank">
        <img alt="Maintainability" src="https://img.shields.io/codeclimate/maintainability/OpenHPS/openhps-<%=projectName%>">

    @openhps/core — <a href="https://openhps.org/docs/<%=projectName%>">API

## Getting Started
If you have [npm installed](https://www.npmjs.com/get-npm), start using @openhps/<%=projectName%> with the following command.
```bash
npm install @openhps/<%=projectName%> --save
```

## Contributors
The framework is open source and is mainly developed by PhD Student Maxim Van de Wynckel as part of his research towards *Hybrid Positioning and Implicit Human-Computer Interaction* under the supervision of Prof. Dr. Beat Signer.

## Contributing
Use of OpenHPS, contributions and feedback is highly appreciated. Please read our [contributing guidelines](CONTRIBUTING.md) for more information.

## License
Copyright (C) 2019-2021 Maxim Van de Wynckel & Vrije Universiteit Brussel

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

repository: OpenHPS/openhps-cli

repo_name: OpenHPS/openhps-cli


text:
# Popular-Algorithm-Questions
# Contains some of the most common algorithm questions along with my solutions.

# Special thanks to this reddit post: https://www.reddit.com/r/cscareerquestions/comments/20ahfq/heres_a_pretty_big_list_of_programming_interview/

Trees

  1. Implement a BST with insert and delete functions

  2. Print a tree using BFS and DFS

  3. Write a function that determines if a tree is a BST

  4. Find the smallest element in a BST

  5. Find the 2nd largest number in a BST

  6. Given a binary tree which is a sum tree (child nodes add to parent), write an algorithm to determine whether the tree is a valid sum tree

  7. Find the distance between 2 nodes in a BST and a normal binary tree

  8. Print the coordinates of every node in a binary tree, where root is 0,0

  9. Print a tree by levels

  10. Given a binary tree which is a sum tree, write an algorithm to determine whether the tree is a valid sum tree

  11. Given a tree, verify that it contains a subtree.

  12. HARD: Find the max distance between 2 nodes in a BST.

  13. HARD: Construct a BST given the pre-order and in-order traversal Strings

repository: alicebalayan/Algorithms

path: /General Problems/Trees/README.md

repo_name: alicebalayan/Algorithms


text:
# EON Demo from sensor data using Arduino and Johnny-Five on Node.js with Express and Jade

## Quick Start
You need to install *Johnny-Five*, *PubNub*, *Jade* and *Express* to run the node.js code with Arduino.

Install all the dependencies:

```bash
$ npm install
```

Start the server:
```bash
$ npm start
```
Then go to `http://localhost:3000` on browser

## Hardware Wiring
### Temperature
The temperature data comes from a [LM35](http://www.ti.com/product/lm35) sensor, and it is published to PubNub.

When you are using Arduino with Johnny-Five, you need to install **StandardFirmataPlus** to your Arduino to be able to run the code.

### Installing StandardFirmataPlus

1. Connect your Arduino to computer with a USB cable.
2. On [Arduino IDE](https://www.arduino.cc/en/Main/Software).
3. Go to **File** > **Examples** > **Firmata** > **StandardFirmataPlus**
4. Upload the code to the device.

Now, you are done with Arduino IDE. You can close it and switch to your fave IDE (or keep using Arduino IDE if you like).

### Arduino wiring
![Arduino wiring](public/img/temperature-lm35.png)

## Example
![EON line graph](public/img/eon-screenshot.png)

## Docs and Websites
* [Website of Johnny-Five](http://johnny-five.io/) - [Docs](https://github.com/rwaldron/johnny-five/wiki)
* [Website of Express](http://expressjs.com/) - [Docs - v4.x](http://expressjs.com/en/4x/api.html)
* [Website of PubNub](https://www.pubnub.com/) - [Docs](https://www.pubnub.com/documentation/)
* [Website of Jade](http://jade-lang.com/) - [Docs](http://jade-lang.com/reference/)

## Credits
An original project of [Tomomi ❤ Imura](https://github.com/girliemac)

repository: jotarios/demo-flisol

path: /Temperature Demo/README.md

repo_name: jotarios/demo-flisol


text:
Evidently

![Dashboard example](https://github.com/evidentlyai/evidently/blob/main/evidently/pics/evidently_4_reports_preview_small.png)

Interactive reports and JSON profiles to analyze, monitor and debug machine learning models.

  Docs
  |
  Join Discord
  |
  Newsletter
  |
  Blog
  |
  Twitter

## What is it?
Evidently helps evaluate machine learning models during validation and monitor them in production. The tool generates interactive visual reports and JSON profiles from pandas `DataFrame` or `csv` files.

You can use **visual reports** for ad hoc analysis, debugging and team sharing, and **JSON profiles** to integrate Evidently in prediction pipelines or with other visualization tools.

Currently 6 reports are available.

### 1. Data Drift
Detects changes in feature distribution.
![Dashboard example](https://github.com/evidentlyai/evidently/blob/main/evidently/pics/evidently_github.png)

### 2. Numerical Target Drift
Detects changes in numerical target and feature behavior.
![Dashboard example](https://github.com/evidentlyai/evidently/blob/main/evidently/pics/evidently_num_target_drift_github.png)

### 3. Categorical Target Drift
Detects changes in categorical target and feature behavior.
![Dashboard example](https://github.com/evidentlyai/evidently/blob/main/evidently/pics/evidently_cat_target_drift_github.png)

### 4. Regression Model Performance
Analyzes the performance of a regression model and model errors.
![Dashboard example](https://github.com/evidentlyai/evidently/blob/main/evidently/pics/evidently_regression_performance_report_github.png)

### 5. Classification Model Performance
Analyzes the performance and errors of a classification model. Works both for binary and multi-class models.
![Dashboard example](https://github.com/evidentlyai/evidently/blob/main/evidently/pics/evidently_classification_performance_report_github.png)

### 6. Probabilistic Classification Model Performance
Analyzes the performance of a probabilistic classification model, quality of model calibration, and model errors. Works both for binary and multi-class models.
![Dashboard example](https://github.com/evidentlyai/evidently/blob/main/evidently/pics/evidently_prob_classification_performance_report_github.png)

## Installing from PyPI
### MAC OS and Linux
Evidently is available as a PyPI package. To install it using pip package manager, run:
```sh
$ pip install evidently
```

The tool allows building interactive reports both inside a Jupyter notebook and as a separate HTML file. If you only want to generate interactive reports as HTML files or export as JSON profiles, the installation is now complete.

To enable building interactive reports inside a Jupyter notebook, we use jupyter nbextension. If you want to create reports inside a Jupyter notebook, then after installing `evidently` you should run the two following commands in the terminal from evidently directory.

To install jupyter nbextention, run:
```sh
$ jupyter nbextension install --sys-prefix --symlink --overwrite --py evidently
```
To enable it, run:
```sh
$ jupyter nbextension enable evidently --py --sys-prefix
```
That's it!

**Note**: a single run after the installation is enough. No need to repeat the last two commands every time.

**Note 2**: if you use Jupyter Lab, you may experience difficulties with exploring report inside a Jupyter notebook. However, the report generation in a separate .html file will work correctly.

### Windows
Evidently is available as a PyPI package. To install it using pip package manager, run:
```sh
$ pip install evidently
```
The tool allows building interactive reports both inside a Jupyter notebook and as a separate HTML file. Unfortunately, building reports inside a Jupyter notebook is not yet possible for Windows. The reason is Windows requires administrator privileges to create symlink. In later versions we will address this issue.

## Getting started

### Jupyter Notebook
To start, prepare your data as two pandas `DataFrames`. The first should include your reference data, the second - current production data. The structure of both datasets should be identical.

* For **Data Drift** report, include the input features only.
* For **Target Drift** reports, include the column with Target and/or Prediction.
* For **Model Performance** reports, include the columns with Target and Prediction.

Calculation results can be available in one of the two formats:
* Option 1: an interactive **Dashboard** displayed inside the Jupyter notebook or exportable as a HTML report.
* Option 2: a JSON **Profile** that includes the values of metrics and the results of statistical tests.

#### Option 1: Dashboard

After installing the tool, import Evidently **dashboard** and required tabs:

```python
import pandas as pd
from sklearn import datasets

from evidently.dashboard import Dashboard
from evidently.tabs import DataDriftTab

iris = datasets.load_iris()
iris_frame = pd.DataFrame(iris.data, columns = iris.feature_names)
```

To generate the **Data Drift** report, run:
```python
iris_data_drift_report = Dashboard(tabs=[DataDriftTab])
iris_data_drift_report.calculate(iris_frame[:100], iris_frame[100:], column_mapping = None)
iris_data_drift_report.save("reports/my_report.html")
```

To generate the **Data Drift** and the **Categorical Target Drift** reports, run:
```python
iris_data_and_target_drift_report = Dashboard(tabs=[DataDriftTab, CatTargetDriftTab])
iris_data_and_target_drift_report.calculate(iris_frame[:100], iris_frame[100:], column_mapping = None)
iris_data_and_target_drift_report.save("reports/my_report_with_2_tabs.html")
```

If you get a security alert, press "trust html".
HTML report does not open automatically. To explore it, you should open it from the destination folder.

To generate the **Regression Model Performance** report, run:
```python
regression_model_performance = Dashboard(tabs=[RegressionPerfomanceTab])
regression_model_performance.calculate(reference_data, current_data, column_mapping = column_mapping)
```

You can also generate a **Regression Model Performance** for a single `DataFrame`. In this case, run:
```python
regression_single_model_performance = Dashboard(tabs=[RegressionPerformanceTab])
regression_single_model_performance.calculate(reference_data, None, column_mapping=column_mapping)
```

To generate the **Classification Model Performance** report, run:
```python
classification_performance_report = Dashboard(tabs=[ClassificationPerformanceTab])
classification_performance_report.calculate(reference_data, current_data, column_mapping = column_mapping)
```

For **Probabilistic Classification Model Performance** report, run:
```python
classification_performance_report = Dashboard(tabs=[ProbClassificationPerformanceTab])
classification_performance_report.calculate(reference_data, current_data, column_mapping = column_mapping)
```

You can also generate either of the **Classification** reports for a single `DataFrame`. In this case, run:
```python
classification_single_model_performance = Dashboard(tabs=[ClassificationPerformanceTab])
classification_single_model_performance.calculate(reference_data, None, column_mapping=column_mapping)
```
or
```python
prob_classification_single_model_performance = Dashboard(tabs=[ProbClassificationPerformanceTab])
prob_classification_single_model_performance.calculate(reference_data, None, column_mapping=column_mapping)
```

#### Option 2: Profile

After installing the tool, import Evidently **profile** and required sections:

```python
import pandas as pd
from sklearn import datasets

from evidently.model_profile import Profile
from evidently.profile_sections import DataDriftProfileSection

iris = datasets.load_iris()
iris_frame = pd.DataFrame(iris.data, columns = iris.feature_names)
```

To generate the **Data Drift** profile, run:
```python
iris_data_drift_profile = Profile(sections=[DataDriftProfileSection])
iris_data_drift_profile.calculate(iris_frame, iris_frame, column_mapping = None)
iris_data_drift_profile.json()
```

To generate the **Data Drift** and the **Categorical Target Drift** profile, run:
```python
iris_target_and_data_drift_profile = Profile(sections=[DataDriftProfileSection, CatTargetDriftProfileSection])
iris_target_and_data_drift_profile.calculate(iris_frame[:75], iris_frame[75:], column_mapping = None)
iris_target_and_data_drift_profile.json()
```

You can also generate a **Regression Model Performance** for a single `DataFrame`. In this case, run:
```python
regression_single_model_performance = Profile(sections=[RegressionPerformanceProfileSection])
regression_single_model_performance.calculate(reference_data, None, column_mapping=column_mapping)
```

To generate the **Classification Model Performance** profile, run:
```python
classification_performance_profile = Profile(sections=[ClassificationPerformanceProfileSection])
classification_performance_profile.calculate(reference_data, current_data, column_mapping = column_mapping)
```

For **Probabilistic Classification Model Performance** profile, run:
```python
classification_performance_report = Profile(sections=[ProbClassificationPerformanceProfileSection])
classification_performance_report.calculate(reference_data, current_data, column_mapping = column_mapping)
```

You can also generate either of the **Classification** profiles for a single `DataFrame`. In this case, run:
```python
classification_single_model_performance = Profile(sections=[ClassificationPerformanceProfileSection])
classification_single_model_performance.calculate(reference_data, None, column_mapping=column_mapping)
```
or
```python
prob_classification_single_model_performance = Profile(sections=[ProbClassificationPerformanceProfileSection])
prob_classification_single_model_performance.calculate(reference_data, None, column_mapping=column_mapping)
```

### Google Colab, Kaggle Kernel, Deepnote
You can run ```evidently``` in [Google Colab](https://colab.research.google.com/), [Kaggle Notebook](https://www.kaggle.com/code) and [Deepnote](https://deepnote.com/).

To use ```evidently``` there start from the installation. Run the following instruction in the notebook  cell:
```!pip install evidently```

There is no need to enable nbextension for this case, because ```evidently``` uses alternative way to display visuals in the hosted notebooks.

To build a ```Dashboard``` or a ```Profile``` simply repeat the steps we described in the previous paragraph, for example to bild **Data Drift** dashboard run the following code:

```python
import pandas as pd
from sklearn import datasets

from evidently.dashboard import Dashboard
from evidently.tabs import DataDriftTab

iris = datasets.load_iris()
iris_frame = pd.DataFrame(iris.data, columns = iris.feature_names)

iris_data_drift_report = Dashboard(tabs=[DataDriftTab])
iris_data_drift_report.calculate(iris_frame[:100], iris_frame[100:], column_mapping = None)
```

To display the dashboard in the Google Colab, Kaggle Kernel, Deepnote run:
```python
iris_data_drift_report.show()
```

The ```show()``` method has the argument ```mode```, wich can take the following options:

* **auto** - the default optoin. Ideally, you will not need to specify the value for ```mode``` and use the default. But, if it does not work (in case we failed to determine the environment automatically), consider setting the correct value explicitly.
* **nbextention** - to show the UI using nbextension. Use this option to display dashboards in jupyter notebooks (should work automatically).
* **inline** - to insert the UI directly into the cell. Use this option for Google Colab, Kaggle Kernels and Deepnote. For Google Colab this should work automatically, for **Kaggle Kernels** and **Deepnote** option should be specified explicitly.

### Terminal
You can generate **HTML reports** or **JSON profiles** directly from the bash shell. To do this, prepare your data as two `csv` files. In case you run one of the performance reports, you can have only one file. The first one should include your reference data, the second - current production data. The structure of both datasets should be identical.

To generate a HTML report, run the following command in bash:

```bash
python -m evidently calculate dashboard --config config.json
--reference reference.csv --current current.csv --output output_folder --report_name output_file_name
```

To generate a JSON profile, run the following command in bash:
```bash
python -m evidently calculate profile --config config.json
--reference reference.csv --current current.csv --output output_folder --report_name output_file_name

```
Here:
- `reference` is the path to the reference data,
- `current` is the path to the current data,
- `output` is the path to the output folder,
- `report_name` is name of the output file,
- `config` is the path to the configuration file,
- `pretty_print` to print the JSON profile with indents (for profile only).

Currently, you can choose the following Tabs or Sections:
- `data_drift` to estimate the data drift,
- `num_target_drift` to estimate target drift for numerical target,
- `cat_target_drift` to estimate target drift for categorical target,
- `classification_performance` to explore the performance of a classification model,
- `prob_classification_performance` to explore the performance of a probabilistic classification model,
- `regression_performance` to explore the performance of a regression model.

To configure a report or a profile you need to create the `config.json` file. This file configures the way of reading your input data and the type of the report.

Here is an example of a simple configuration for a report, where we have comma separated `csv` files with headers and there is no `date` column in the data.

**Dashboard**:
```bash
{
  "data_format": {
    "separator": ",",
    "header": true,
    "date_column": null
  },
  "column_mapping" : {},
  "dashboard_tabs": ["cat_target_drift"]
}
```

**Profile**:
```bash
{
  "data_format": {
    "separator": ",",
    "header": true,
    "date_column": null
  },
  "column_mapping" : {},
  "profile_sections": ["data_drift"],
  "pretty_print": true
}
```

Here is an example of a more complicated configuration, where we have comma separated `csv` files with headers and `datetime` column. We also specified the `column_mapping` dictionary to add information about `datetime`, `target` and `numerical_features`.

**Dashboard**:
```bash
{
  "data_format": {
    "separator": ",",
    "header": true,
    "date_column": "datetime"
  },
  "column_mapping" : {
    "datetime":"datetime",
    "target":"target",
    "numerical_features": ["mean radius", "mean texture", "mean perimeter",
      "mean area", "mean smoothness", "mean compactness", "mean concavity",
      "mean concave points", "mean symmetry"]},
  "dashboard_tabs": ["cat_target_drift"],
  "sampling": {
      "reference": {
      "type": "none"
    },
      "current": {
      "type": "nth",
      "n": 2
    }
  }
}
```

**Profile**:
```bash
{
  "data_format": {
    "separator": ",",
    "header": true,
    "date_column": null
  },
  "column_mapping" : {
    "target":"target",
    "numerical_features": ["mean radius", "mean texture", "mean perimeter",
      "mean area", "mean smoothness", "mean compactness", "mean concavity",
      "mean concave points", "mean symmetry"]},
  "profile_sections": ["data_drift", "cat_target_drift"],
  "pretty_print": true,
  "sampling": {
    "reference": {
      "type": "none"
    },
    "current": {
      "type": "random",
      "ratio": 0.8
    }
  }
}
```

## Telemetry
When you use Evidently in the command-line interface, we collect basic telemetry (starting from 0.1.21.dev0 version). It includes data on the environment (e.g. Python version) and usage (type of report or profile generated). You can read more about what we collect [here](https://docs.evidentlyai.com/support/telemetry).

You can opt-out from telemetry collection by setting the environment variable EVIDENTLY_DISABLE_TELEMETRY=1

## Large datasets

As you can see from the above example, you can specify **sampling** parameters for large files. You can use different sampling strategies for reference and current data, or apply sampling only to one of the files.
Currently we have 3 sampling types available:
* `none` - there will be no sampling for the file,
* `nth` - each Nth row of the file will be taken. This option works together with `n` parameter (see the example with the Dashboard above)
* `random` - random sampling will be applied. This option works together with `ratio` parameter (see the example with the Profile above)

## Documentation

For more information, refer to a complete Documentation.

## Examples

- See **Data Drift** Dashboard and Profile generation to explore the results both inside a Jupyter notebook and as a separate .html file:
[Iris](https://colab.research.google.com/drive/1TCdDjuiMzvSyjkIJOwYl2dkN8N56c00Z?authuser=1),
[Boston](https://colab.research.google.com/drive/1J8FvINy5nX47L5-iklsGD4C4y1Zi1Wlo?authuser=1)

- See **Categorical Target and Data Drift** Dashboard and Profile generation to explore the results both inside a Jupyter notebook and as a separate file:
[Iris](https://colab.research.google.com/drive/18HvFvZeIjOmbAV7KVL103PlWlFuIjdGj?authuser=1),
[Breast Cancer](https://colab.research.google.com/drive/157kTbk-uZKi4Q6Eea3yaEbLrpR_h_Pow?authuser=1)

- See **Numerical Target and Data Drift** Dashboard and Profile generation to explore the results both inside a Jupyter notebook and as a separate file:
[Boston](https://colab.research.google.com/drive/1IDE02r-Xh-T4k5Yw3SpRGlewHOS8ZsmX?authuser=1)

- See **Regression Performance** Dashboard and Profile generation to explore the results both inside a Jupyter notebook and as a separate file:
[Bike Sharing Demand](https://colab.research.google.com/drive/1VA1KjBYxMRfccSS5IXAClBGKB9Lw7WtP?authuser=1)

- See **Classification Performance** Dashboard and Profile generation to explore the results both inside a Jupyter notebook and as a separate file:
[Iris](https://colab.research.google.com/drive/1SAsaUTUaIzg3FyI_EbmO9hzuEu1hVl4v?authuser=1)

- See **Probabilistic Classification Performance** Dashboard and Profile generation to explore the results both inside a Jupyter notebook and as a separate .html file:
[Iris](https://colab.research.google.com/drive/1uFN0ZWNLk3ExylBywq_M8oGkmac0lDrq?authuser=1),
[Breast Cancer](https://colab.research.google.com/drive/1vwEBgGnDVk5BJG2PXT1w41VfZ-_bq_Sw?authuser=1)

## Stay updated
We will be releasing more reports soon. If you want to receive updates, follow us on [Twitter](https://twitter.com/EvidentlyAI), or sign up for our [newsletter](https://evidentlyai.com/sign-up). You can also find more tutorials and explanations in our [Blog](https://evidentlyai.com/blog). If you want to chat and connect, join our [Discord community](https://discord.gg/xZjKRaNp8b)!

repository: nicolizamacorrea/evidently

repo_name: nicolizamacorrea/evidently


text:
# LC-CrowdControl
Java Library to provide CrowdControl support to games.

The library provides a core api (needed at compile time), and a series of connectors (needed at runtime).

Currently the connectors support an augmented version of the CrowdControl TCP v1 Protocol. When details are available, TCP v2 will be supported.

On all provided connectors, Effect discovery is provided for compatible servers.

Upon Connection, a Discovery Compatible Pack can send Discovery Compatible Games a `__DISCOVER` effect using the Test type.
The client can then respond with either a Retry, or a Success where the supported effects are provided in the message.  Upon Retry, the request may be resubmitted (message is unused, and MUST be ignored).

repository: LightningCreations/LC-CrowdControl

repo_name: LightningCreations/LC-CrowdControl


text:
# meager_matrix

[![Build Status](https://travis-ci.com/ECE421/meager_matrix.svg?branch=master)](https://travis-ci.com/ECE421/meager_matrix)
[![codecov](https://codecov.io/gh/ECE421/meager_matrix/branch/master/graph/badge.svg)](https://codecov.io/gh/ECE421/meager_matrix)

## Description
`meager_matrix` is ruby sparse matrix library that takes inspiration from
SciPy's implementation of sparse matrices.

The Ruby Version this library was written in is 2.5.3

## Usage
TODO: fill in

## References
* [SciPy](https://www.scipy.org/)
* [SciPy Sparse Matrices](https://docs.scipy.org/doc/scipy/reference/sparse.html)

gha_language: Ruby


text:
# Pro Landscaping Kit

Allows previously unscrappable plants to be scrapped into Compost and eventually converted into Fertilizer

## Recipes

Workbench | Recipe | Ingredients
--- | --- | ---
Chemistry Station | 1x Bag of Fertilizer | 1x Purified Water, 20x Compost
Chemistry Station | 1x Bag of Fertilizer | 4x Dirty Water, 20x Compost

## Affected Plants

* Boxwood
* Brambles
* Cattails
* Corn Stalk Debris
* Creosote Bush
* Dead Tato Plants
* Ferns
* Flowers
* Forsythia
* Fungus Stalks
* Grass
* Hedges
* Institute Evergreens
* Institute Hydro Plants
* Kelp
* Leaves
* Moss
* Roots
* Rose Bush
* Saplings
* Seaweed
* Shrubs
* Vines

path: /Pro Landscaping Kit/README.md