text:
# 내손의서당 [chunjabasic]
[내손의서당](https://play.google.com/store/apps/details?id=com.tegine.chunjabasic)
[https://play.google.com/store/apps/details?id=com.tegine.chunjabasic](https://play.google.com/store/apps/details?id=com.tegine.chunjabasic)
안드로이드 프로젝트 내손의 서당을 공개합니다:

1. 이 코드를 사용함에 따른 모든 책임은 사용자가 집니다.
2. 맘껏 가져다 이용하세요. 가능할지 모르나 상용도 가능합니다.
3. 대한민국 학생들에 대한 프로그래밍 교육을 환영합니다.
4. 내가 프로그래밍 해봐서 아는데... 하는 갑의 횡포를 두려워 합니다.

이 프로젝트는 구글플레이-내손의서당 의 공개버젼입니다.:
* 이클립스를 이용하였습니다.
* 뭐 혹시나 코드에서 아! 이러구나.. 라던가... 헐 이건 뭐지?
이럼 안되겠다 같은것을 느끼셔서 도움 되셨다면,
광고 한번 눌러 주... 씁... 강제는 아닙니다. ㅋㅋ

* this is MIT License.

Copyright (c) 2015 tegine.com

Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

# chunjabasic

Copyright (c) 2015 tegine.com

Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

* this is MIT License.

* If you feel "Wow! this is cool..." or "Shxx ... This code is terrible.."
then I think...
I help your coding level up... -Anyway...

So touch Commercial f.... XXX. <- this is not force...

license: MIT

repository: darkhani/chunjabasic

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: darkhani/chunjabasic


text:
---
layout: post
title: "GSoC'19 - CaMicroscope"
excerpt: "Work done during Google Summer of Code - 2019 under Biomedical Informatics, Emory University."
categories: [GSoC-19]
comments: true
---

## Synopsis

### About caMicroscope
> caMicroscope is a  Web Based Annotation and Visualization Platform for Digitized Whole Slide Images.

 It is a tool to view, annotate, and analyze whole-slide, biomedical images. It manages digital pathology images, associated clinical and imaging metadata, and human/machine generated annotations and markups.

### About the project
The goal of this project is to allow model developers to test their trained models on the selected area of WSI.

### Why this feature is needed
In general, the deep learning models are tested on a batch of images and later the predictions are visualized using various tools. If a whole slide image pertaining to a model is available, the model developer has to manually crop the required region he/she wants to test the performance on. This can be tedious if one wishes to test on specific regions of the WSI.

By the addition of this feature to allow testing the models in the image viewer itself will likely improve the productivity and would allow the developer to have better insights about the performance of the model by being able to test it across the WSI.

### What is implemented
caMicroscope has an app that allows nuclei segmentation using watershed algorithm. It is extended to allow user to upload and test the segmentation models.
An additional app to allow user to upload and test the classification models.

### How it is implemented
The proposed features are implemented using TensorFlow.js. TensorFlow.js is a library for developing and training ML models in JavaScript and deploying in browser.

Models developed using Keras are compatible after a straighforward conversion.

### Mentors
- Ryan Birmingham

- Nan Li

## Background

### Whole Slide Imaging
Whole slide imaging[^1] refers to scanning of conventional glass slides in order to produce digital slides. Prior to the introduction of WSI, digital imaging in anatomic pathology relied largely on microscope-mounted cameras to produce “static” digital images. These static images were of limited clinical utility because they captured only specific regions of a glass slide. WSI, also commonly referred to as “virtual microscopy”, aims to emulate conventional light microscopy in a computer-generated manner.

Practically speaking, WSI consists of two processes. The first process utilizes specialized hardware (scanner) to digitize glass slides, which generates a large representative digital image (so-called “digital slide”). The second process employs specialized software (ie, virtual slide viewer) to view and/or analyze these enormous digital files. *caMicroscope* is one such virtual slide viewer.

[^1]: [Whole slide imaging in pathology: Advantages, limitations, and emerging perspectives](https://www.dovepress.com/whole-slide-imaging-in-pathology-advantages-limitations-and-emerging-p-peer-reviewed-article-PLMI)

### TensorFlow.js
The models are executed in the client's browser using TensorFlow.js. The viewer of segment and predict app allows the user to draw the region of interest in the integral multiple of the input patch/image size of the model. The model is executed on each window. The models are temporary stored using IndexedDB to make it possible to compare the performance of models on the different ROIs.

For classification, i.e., predict app, the result displayed in the class with maximum average probability across all the windows. A CSV file can be downloaded which contains the probabilities of individual classes.

For segmentation, the user can adjust the opacity of the mask to verify the performance of the model.

## How to use

First the model is to be uploaded. While uploading, make sure to fill in correct values for input size and image type. While uploading the model is tested to ensure only valid models are saved in the IDB.

Both the apps have the similar toolbar. After uploading the model, the user can select the model & pre-processing method and draw the ROI by checking the first tool. The selected model will be executed.

The user can save ROI, mask, probabilties using relevant tools.
A detailed user guide can be found [here](https://docs.google.com/document/d/127LIvqi_f3QzYQNYDXJm83AWVhq56igG4HpVa5xy-FM/edit?usp=sharing).

It is recommended to test the model on the same zoom level as the training images.

### Creating models compatible with caMicroscope

caMicroscope uses TensorFlow.js for deploying machine learning models.
Keras models (typically created via the Python API) may be saved in one of the several formats. The "whole model" format can be converted to TensorFlow.js Layers format, which can be loaded into caMicroscope. You’ll need to install the converter

`pip install tensorflowjs`

{% highlight python %}
  import tensorflowjs as tfjs
  import keras

  model = keras.models.Sequential()   # for example
  ...
  model.compile(...)
  model.fit(...)
  tfjs.converters.save_keras_model(model, tfjs_target_dir)
{% endhighlight %}

Or if you already have Keras model in the format model.hdf5, convert to TensorFlow.js Layers format using the following bash command:

{% highlight bash %}
  tensorflowjs_converter --input_format keras \
                       path/to/my_model.hdf5 \
                       path/to/tfjs_target_dir
{% endhighlight %}

The target TensorFlow.js Layers format is a directory containing a model.json file and a set of sharded weight files in binary format. The model.json file contains both the model topology (aka "architecture" or "graph": a description of the layers and how they are connected) and a manifest of the weight files.

If you’re uploading an offline copy, upload the model.json in the first input and all (and only) weight files in the second input. If the model is hosted, toggle to link a hosted model and enter the URL to model.json.
A demo is linked [here](https://drive.google.com/open?id=1-8DYL6OVd9k6zpcLD4jcd6pOpQl2u__z).

### Pull Requests

#### Phase 1
* [Add support for Classification models](https://github.com/camicroscope/caMicroscope/pull/187)
* [Classification sample models](https://github.com/Insiyaa/caMicroscope-tfjs-models/tree/master/Classification%20Sample%20Models)

#### Phase 2
* [Add support for segmentation models](https://github.com/camicroscope/caMicroscope/pull/195)

#### Phase 3
* [Change UI and patchwise prediction instead of hard resize](https://github.com/camicroscope/caMicroscope/pull/197)
* [Allow to select preprocessing technique](https://github.com/camicroscope/caMicroscope/pull/198)
* [Segmentation sample models](https://github.com/Insiyaa/caMicroscope-tfjs-models/tree/master/Segmentation%20Sample%20Models/mitosis-segmentation)

## How to contribute
caMicroscope should be deployed as part of a stack.

- Clone [caMicroscope](https://github.com/camicroscope/caMicroscope).
- Clone the Docker distribution from [camicroscope/Distro](https://github.com/camicroscope/Distro).

- In the above repo, edit *caMicroscope.yml* and mount the cloned repo of caMicroscope as a volume under viewer as below.

{% highlight yml %}
  viewer:
    build: "../caMicroscope"
    container_name: ca-front
    volumes:
      - ./config/login.html:/var/www/html/login.html
      - ../caMicroscope/:/var/www/html/
{% endhighlight %}

- Change the current directory to Distro

    `cd Distro`

- Run with

    `docker-compose -f caMicroscope.yml up`

- Once everything is up, go to http://localhost:4010/.

## Future improvements

* Support for tensorflow/tf_hub graph models. Currently (Aug-2019), tensorflow.js allows saving only the layersModel. The graph models are supposed to be used right away and can't be stored. Tf_hub models are to be downloaded everytime. This issue is tracked [here](https://github.com/tensorflow/tfjs/issues/1701). Although, an experimental feature can be added to use graphModels right away.

### End note:
I really enjoyed working on the project. The most important part is I learnt a lot many technologies while working on this project. I realised a lot many areas I need to work on. This whole program made me a better developer than I was before.

I'd like to thank my mentors for being supportive during this whole period and guiding me! :)

gha_language: CSS


text:
# fluente

[![npm version](https://badge.fury.io/js/fluente.svg)](https://badge.fury.io/js/fluente)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
[![Dependencies Status](https://david-dm.org/greguz/fluente.svg)](https://david-dm.org/greguz/fluente.svg)
[![Actions Status](https://github.com/greguz/fluente/workflows/ci/badge.svg)](https://github.com/greguz/fluente/actions)
[![Coverage Status](https://coveralls.io/repos/github/greguz/fluente/badge.svg?branch=master)](https://coveralls.io/github/greguz/fluente?branch=master)

Make fluent objects like a boss!

## Features

- **Zero dependencies**: small footprint.
- **Protected state**
- **Selective mutability**: choose between immutable objects or a classy object.
- **Undo/Redo out of the box**
- **TypeScript support**

## Installation

```
npm install --save fluente
```

## fluente(options)

Returns the build object.

- `options` `<Object>`
  - `state` `<Object>` Initial state.
  - `[constants]` `<Object>` Constant values.
  - `[getters]` `<Object>` Value getters.
  - `[fluents]` `<Object>` Fluent methods.
  - `[mappers]` `<Object>` Map (normal) methods.
  - `[mutable]` `<Boolean>` See [mutability](#mutability).
  - `[historySize]` `<Number>` See [undo and redo](#undo-and-redo).
  - `[produce]` `<Function>` See [state manipulation](#state-manipulation).
- Returns: `<Object>`

## Quickstart

The easiest way to create a _fluent_ API is by returning the instance itself inside a class method.

```javascript
class Calculator {
  constructor (value = 0) {
    this.value = value
  }

  add (value) {
    this.value += value
    return this // Fluent API
  }

  valueOf () {
    return this.value
  }
}

const calculator = new Calculator(0)

const value = calculator
  .add(2)
  .add(4)
  .add(8)
  .add(16)
  .valueOf()

console.log(value) // 30
```

Fluente provides a different way to declare _fluent_ objects.

```javascript
const fluente = require('fluente')

const symCalculator = Symbol('my_calculator')

function valueOf (state) {
  return state.value
}

function add (state, value) {
  return {
    value: valueOf(state) + value
  }
}

function subtract (state, value) {
  return {
    value: valueOf(state) - value
  }
}

function multiply (state, value) {
  return {
    value: valueOf(state) * value
  }
}

function divide (state, value) {
  return {
    value: valueOf(state) / value
  }
}

function createCalculator (value = 0) {
  return fluente({
    // Enable state history (undo/redo)
    historySize: 8,
    // Initial state
    state: {
      value
    },
    // Object constants
    constants: {
      [symCalculator]: true
    },
    // Value getters
    getters: {
      value: valueOf,
      integer: state => Number.isInteger(valueOf(state))
    },
    // Fluent methods
    fluents: {
      add,
      subtract,
      multiply,
      divide
    },
    // Map (normal) methods
    mappers: {
      valueOf
    }
  })
}

const zero = createCalculator(0)

// Read constant value
if (zero[symCalculator] !== true) {
  throw new Error('Expected calculator')
}

// Read value getters
console.log(zero.value, zero.integer) // 0 true

// Use fluent method
const pi = zero.add(Math.PI)

console.log(pi.value, pi.integer) // 3.141592653589793 false

const value = zero
  .add(2)
  .subtract(8)
  .multiply(-1)
  .divide(2)
  .undo(2) // Undo 2 mutations: divide(2) and multiply(-1)
  .redo(1) // Redo 1 mutation: multiply(-1)
  .valueOf() // Use map method

console.log(value) // 6
```

Like a `constructor`, Fluente returns an object. You can still declare methods, constants, and getters, but with a different signature. Functions do not use the `this` keyword to access the state. Instead, It's always passed as the first argument. Another key difference is how fluent methods mutate the state: by returning an object that contains the changed values.

These rules abstract the methods (and getters) definition and the state mutation, unlocking some cool features like selective mutability, state protection, and undo/redo.

## Mutability

By default, all objects build by Fluente are **immutable** (all _fluent_ methods will return a new object containing the updated state). You can retrieve mutable objects using the `mutable` option.

```javascript
const fluente = require('fluente')

function createCalculator (initialValue = 0) {
  return fluente({
    mutable: true, // Request mutable object
    state: {
      value: initialValue
    },
    fluents: {
      add (state, value) {
        return {
          value: state.value + value
        }
      }
    },
    mappers: {
      valueOf (state) {
        return state.value
      }
    }
  })
}

const calculator = createCalculator(0)
calculator.add(40)
calculator.add(2)
console.log(calculator.valueOf()) // 42
```

## Undo and Redo

An isolated state enables easy undo-redo implementation. The current state represents the present moment. Applying a mutation move the present into the past, and set a new present state. Undoing a mutation will restore a state from the past, and move the present state into the future. Redoing a mutation will do the opposite. A more detailed example is available in [this](https://redux.js.org/recipes/implementing-undo-history) Redux article.

Fluente automatically injects undo-redo functions. Both functions optionally accept the number of mutations to apply, defaulting to `1` mutation. `Infinity` is accepted, and means "redo/undo all the mutations available".

The `historySize` option controls the max number of mutations remembered by Fluente. Set the `historySize` option to a positive number to enable this feature.

## State manipulation

By default, all fluent functions need to return an updated state, even partially, to let Fluente know **what** is changed. Plus state needs to be treated as **immutable**. Those rules are necessary to ensure correct state isolation. The `subtract` function in the next example is updating the state's `value` property by returning an object containing that property.

```javascript
function subtract (state, value) {
  return {
    value: state.value - value
  }
}
```

However, other state manipulation systems are viable through a custom Producer. A Producer is a function that accepts both state object and map function. Its purpose is to handle any map mutations applied against the state and then return a new and fully updated state.

```javascript
const fluente = require('fluente')

function mySimpleProducer (oldState, mapper) {
  // Clone current state
  const newState = Object.assign({}, oldState)
  // Run state mapper (may override some root properties now)
  mapper(newState)
  // Return updated state
  return newState
}

function createCalculator (initialValue = 0) {
  return fluente({
    produce: mySimpleProducer, // Use a custom producer
    state: {
      value: initialValue
    },
    fluents: {
      add (state, value) {
        state.value += value // Direct state manipulation
      }
    },
    mappers: {
      valueOf (state) {
        return state.value
      }
    }
  })
}
```

The easiest and safest way to support direct state manipulation is to use [Immer](https://www.npmjs.com/package/immer)'s `produce` function.

```javascript
const fluente = require('fluente')
const { produce } = require('immer')

function createCalculator (initialValue = 0) {
  return fluente({
    produce, // Use Immer to handle state changes
    state: {
      value: initialValue
    },
    fluents: {
      add (state, value) {
        state.value += value // Direct state manipulation
      }
    },
    mappers: {
      valueOf (state) {
        return state.value
      }
    },
  })
}
```

[Immutable.js](https://www.npmjs.com/package/immutable) is also supported.

```javascript
const fluente = require('fluente')
const { Map } = require('immutable')

function valueOf (state) {
  return state.get('value')
}

function add (state, value) {
  return state.set('value', valueOf(state) + value)
}

function createCalculator (initialValue = 0) {
  return fluente({
    // Direct mapping (fluent mappers need to return the updated state)
    produce: (state, mapper) => mapper(state),
    // Initial state (init with Immutable.js)
    state: Map({
      value: initialValue
    }),
    fluents: {
      add
    },
    mappers: {
      valueOf
    }
  })
}
```

repository: greguz/fluente

gha_language: JavaScript

gha_license_id: MIT

repo_name: greguz/fluente


text:
# personal-data-erasure

Export and delete all customer data from the commercetools platform.

## Install

```bash
npm install @commercetools/personal-data-erasure --global
```

repository: commercetools/nodejs

repo_name: commercetools/nodejs


text:
---
organizers:
  -
    name: 张明序
    id: 2020XXXXXXX032
  -
    name: 温世豪
    id: 2020XXXXXXX030
  -
    name: 李金合
    id: 2020XXXXXXX092
title: Advance of Artificial Intelligence of SiChuan University
shorttitle: AAISCU
only-for-homework: true
accept-chinese-submission: true
score1: 60
score2: 60
comments: "主题和标题不匹配, 列出的topic与主题和标题都不太匹配，网页复制粘贴内容较多"
---

## Call for Papers

With the development of artificial intelligence theory and technology, the application scope of artificial intelligence in various fields is also expanding. In order to strengthen the construction of national cyberspace security and promote artificial intelligence to achieve more academic innovation and Technological Development in more Cyberspace Security related fields, "2021 Sichuan University artificial intelligence society" will be held in Chengdu in May 2021 under the guidance of the school of Cyberspace Security of Sichuan University. The conference will conduct academic exchanges and discussions on typical applications of Cyberspace Security, analyze hot issues, propose technological innovations and show results. To this end, the conference will solicit academic papers in this field from home and abroad.

In order to showcase the latest research results of Sichuan University in artificial intelligence algorithms and its applications, and to deepen the technical exchanges between multiple application fields, the conference has extensively collected academic papers in this field in the School of Network Security.

In order to ensure the availability and professionalism of the research, AAISCU will review the papers according to the research directions and innovation points corresponding to their research fields.

## Topics
  * ### Network & Systems Security

  **Track chair: [Xingshu Chen](http://ccs.scu.edu.cn/info/1052/2599.htm)(SCU, CHN)**

  **See [Example Paper](https://ieeexplore.ieee.org/document/8846762)**

  This topic demonstrates the methods of using artificial intelligence tools for Network&systems security, including but not limited to the following aspects：

      - Anti-malware techniques: detection, analysis, and prevention
	  - Cyber attack (e.g., APTs, botnets, DDoS) prevention, detection, investigation, and response
	  - Cyber-crime defense and forensics (e.g., anti-phishing, anti-blackmailing, anti-fraud techniques)
	  - Security and privacy of mobile/smartphone platforms
	  - Security and privacy for blockchains and cryptocurrencies
	  - Security of Web-based applications and services
	  - Threat intelligence analysis
	  - Software testing
	  - Network traffic analysis
	  - Public opinion monitoring
	  - Program analysis technology

  * ### Multimedia Security

  **Track chair: [Hongxia Wang](http://ccs.scu.edu.cn/info/1052/2601.htm)(SCU, CHN)**

  **See [Example Paper](https://ieeexplore.ieee.org/document/8979156)**

  This topic demonstrates the methods of using artificial intelligence tools for multimedia security, including but not limited to the following aspects：

	  - Tamper detection
	  - Steganography and steganalysis
 	  - Synthetic multimedia detection
 	  - Anti-spoofing detection
 	  - Generative adversarial networks
 	  - Fake news generative
 	  - Fake multimedia synthetise

## Important Dates
  * **July 01, 2021**: Full Paper & Special Session Submission.
  * **August 20, 2021**: Notification of Paper Acceptance.
  * **August 30, 2021**: Camera-ready Paper Upload.

## Submission
  * Send your full paper to the email<EMAIL_ADDRESS>directly.

## Format Download
  * [Click Here to Download Conference Templete](https://www.latextemplates.com/template/a0poster-portrait-poster).

Copyright@School of Cyber Science and Engineering

repository: scuzyx/cfp

branch_name: refs/heads/main

repo_name: scuzyx/cfp


text:
|        Linux        |       Windows       |      Test Coverage       |     SonarSource        |        Codacy             |
|:-------------------:|:-------------------:|:------------------------:|:----------------------:|:-------------------------:|
| [![travisCI][1]][2] | [![appveyor][3]][4] | [![coveralls][5]][6]     | [![sonarsource][7]][8] | [![Codacy Badge][9]][10] |

[1]: https://travis-ci.org/fkutzner/JamSAT.svg?branch=master
[2]: https://travis-ci.org/fkutzner/JamSAT
[3]: https://ci.appveyor.com/api/projects/status/88983cn7gmg91b3s/branch/master?svg=true
[4]: https://ci.appveyor.com/project/fkutzner/jamsat/branch/master
[5]: https://coveralls.io/repos/github/fkutzner/JamSAT/badge.svg?branch=master
[6]: https://coveralls.io/github/fkutzner/JamSAT?branch=master
[7]: https://sonarcloud.io/api/project_badges/measure?project=jamsat&metric=alert_status
[8]: https://sonarcloud.io/dashboard?id=jamsat
[9]: https://api.codacy.com/project/badge/Grade/9e68cb1a29c94839a5456c6d75d6b6b0
[10]: https://app.codacy.com/app/fkutzner/JamSAT?utm_source=github.com&utm_medium=referral&utm_content=fkutzner/JamSAT&utm_campaign=badger

# JamSAT

JamSAT is a fast, clean incremental
[SAT](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem)
solver implementing the
[IPASIR interface](https://github.com/biotomas/ipasir). Though
not being a descendant of [Minisat](http://minisat.se),
this solver is heavily influenced by Minisat,
[Glucose](http://www.labri.fr/perso/lsimon/glucose/) and
the [Candy Kingdom](https://github.com/Udopia/candy-kingdom).
Hence the marmalade-themed name.

Being a relatively young SAT solver as well as a side
project, JamSAT is yet missing some important
features. The [implementation status](#implementation-status)
section contains a summary of its capabilities.

JamSAT is free software distributed under the [MIT license](LICENSE)
(X11 variant).

Table of contents:
1. [Scope](#scope)
2. [Supported Platforms and Ecosystems](#supported-platforms-and-ecosystems)
3. [Building JamSAT](#building-jamsat)
4. [Using JamSAT](#using-jamsat)
5. [Implementation Status](#implementation-status)
6. [Developer Documentation](#developer-documentation)

## Scope

While JamSAT can be used as a generic SAT solver, its focus lies on
solving problem instances arising from industrial applications such
as model checking, artificial intelligence, circuit equivalence checking
and SMT solving. More
specifically, it is optimized for _agile_ SAT solving: it is designed
to efficiently solve vast numbers of SAT problem instances that are
not very hard individually.

## Supported Platforms and Ecosystems

JamSAT is regularly built and tested using the following
configurations:

| Operating System    | Compilers                              |
|---------------------|----------------------------------------|
| GNU/Linux           | clang 7, gcc 8                         |
| Apple macOS         | clang (XCode 10.1 / Apple Clang 10)    |
| Microsoft Windows   | Visual C++ 2017                        |

A compiler supporting C++17 is required to build JamSAT.

JamSAT integrates nicely with [CMake](http://cmake.org) projects.
The repository
contains an [example](examples/ipasirclient) showing how to
use JamSAT in client applications. Support for
[pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/)
is planned, but not yet implemented.

## Building JamSAT

The following prerequisites must be present on your system:
* CMake (at least version 3.12)
* a C++ compiler with C++17 support
* [Boost](https://www.boost.org) (at least version 1.59)
* [zlib](https://github.com/madler/zlib)
* (optionally) [GSL](https://github.com/microsoft/GSL) (at least
  version 3.1.0; see the option `JAMSAT_USE_VENDORED_GSL`)

### Building without tests

To build JamSAT, execute the following commands, with
`<I>` being the directory where JamSAT shall be installed:

```
git clone https://github.com/fkutzner/JamSAT
cd JamSAT
git submodule init
git submodule update
cd ..
mkdir JamSAT-build
cd JamSAT-build
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=<I> ../jamsat
cmake --build . --target install
```

_Note for Windows builds_: You'll need to pass the path
to Boost and the zlib installation to the first `cmake`
invocation as well. See the [AppVeyor configuration](appveyor.yml)
for a build recipe.

### Building with tests

Building the JamSAT test suite can be enabled by additionally
passing the argument `-DJAMSAT_ENABLE_TESTING=ON` to the first
`cmake` invocation.

To run the test suite, navigate to JamSAT's
build directory (e.g. the `JamSAT-build` created in the script above) and run
`ctest`. JamSAT supports fuzz testing with
[afl-fuzz](http://lcamtuf.coredump.cx/afl/). To enable
fuzzing, pass `-DJAMSAT_ENABLE_AFL_FUZZER=ON` to the first
`cmake` invocation. You can then fuzz-test JamSAT by
building the target `barecdclsolver_fuzzer-run`. Fuzzing results
will be placed in the directory
`bin/barecdclsolver_fuzzer-fuzzer-findings`.

See the [Travis CI build script](etc/TravisBuild.sh) or
[AppVeyor configuration](appveyor.yml) for a more detailed
description of building with testing enabled.

### Build Options

Set options by passing `-D<OPTION>=ON|OFF` to `cmake`, e.g.
`-DJAMSAT_ENABLE_TESTING=ON`. Unless otherwise noted, options are set to `OFF`
by default. The list of JamSAT build options is given below.

#### Controlling the scope of the build

* `JAMSAT_ENABLE_TESTING` - Enable building the JamSAT test suite.

#### 3rd party libraries

* `JAMSAT_USE_SYSTEM_GSL` - Search for the Microsoft GSL in the CMake module
search path. If `OFF` (which is the default), the GSL included in `deps/GSL`
is used for building JamSAT.

#### General compiler and linker settings

* `JAMSAT_BUILD_STATIC_LIB` - Build the JamSAT library as a static library
* `JAMSAT_DISABLE_BOOST_LINKING_SETUP` - Don't override linker settings for Boost

#### Logging

* `JAMSAT_ENABLE_LOGGING` - Enable logging.
* `JAMSAT_LOGGING_DEFAULT_START_EPOCH` - The first logging epoch in which
logging is performed. Currently, a new logging epoch starts at every CDCL
conflict. After this logging epoch, logging remains enabled. The default
value is 0. This option only has an effect if `JAMSAT_ENABLE_LOGGING` is
set to `ON`.

When logging is enabled, JamSAT emits very fine-grained logging information.
This can slow down the solver and produce masses of extraneous data, making
it infeasible to use full logging for large SAT problem instances. For
effective logging, either
* use fuzz testing to find a small input example for the bug you're trying
  to fix and use full logging to understand it,
* or use the `JAMSAT_LOGGING_DEFAULT_START_EPOCH` option to restrict logging
  to the last few (1000 to 10000) conflicts before observing the behaviour
  you are investigating.

#### Debugging
* `JAMSAT_ENABLE_AFL_FUZZER` - Use afl-clang rsp. afl-gcc for compilation and
  build the fuzzing targets for AFL
* `JAMSAT_DISABLE_OPTIMIZATIONS` - Disable compiler optimimzations
* `JAMSAT_ENABLE_ASAN` - Enable the address sanitizer if the compiler supports
  address sanitizing
* `JAMSAT_ENABLE_UBSAN` - Enable the undefined-behaviour sanitizer if the
  compiler supports undefined-behaviour sanitizing
* `JAMSAT_ENABLE_RELEASE_ASSERTIONS` Enable release-mode assertions
* `JAMSAT_ENABLE_EXPENSIVE_ASSERTIONS` - Enable more thorough, but expensive
  assertions
* `JAMSAT_ENABLE_COVERAGE` - Enable code coverage measurements. Currently only
  works on Linux and macOS and produces `lcov`-readable coverage data.

## Using JamSAT

See [Using JamSAT](doc/UsingJamSAT.md)

## Implementation Status

| Capability              | Status                  |
| ----------------------- | :----------------------:|
| Incremental SAT solving | Supported               |
| IPASIR interface        | Mostly supported        |
| Problem simplification  | Partially supported     |
| UNSAT Certificates      | TODO                    |

### Problem Simplification
JamSAT employs inprocessing techniques to simplify the
problem-instance during the solving process, leveraging
lemmas derived from the instance. Currently, JamSAT
implements the following techniques:

* Clause subsumption with hyper-binary resolution
* Self-subsuming resolution with hyper-binary resolution
* Failed Literal Elimination

### IPASIR Implementation Status

| Function | Status |
| -------- | :----: |
| ipasir_signature | Supported |
| ipasir_init | Supported |
| ipasir_release | Supported |
| ipasir_add | Supported |
| ipasir_assume | Supported |
| ipasir_solve | Supported |
| ipasir_val | Supported |
| ipasir_failed | Supported |
| ipasir_set_terminate | Supported |
| ipasir_set_learn  | TODO |

## Developer Documentation

* Reference manual: Build the target `doxygen` to generate JamSAT's developer
documentation, which can then be browsed at
`<JamSAT-Build-Dir>/doc/html/index.html`. The
[Doxygen](https://www.stack.nl/~dimitri/doxygen/) documentation system is
required to build the documentation.
* [Repository description](doc/Repository.md)

repository: fkutzner/JamSAT

repo_name: fkutzner/JamSAT


text:
**SexyBack** 是Justin Timberlake曲风定义的一首标志性的歌曲。Justin
TImberlake作为一个美国歌手，艰辛是很大的，但就是因为这首sexy back
让所有艰辛变成了动力。在金牌制作人Timbaland的协助和众多人不看好的情况下，勇于为单飞后的性感转身做了个好头。推出后，马上引起巨大反响，被评为当年最性感男人。sexy
back 也是Jusin
Timberlake最喜欢的歌曲之一，因为成功，而且是自己的原意。几乎每场show或者演唱会都有唱。甚至在和日本smap的会见中也只简短唱了sexy
back和rock your body两首，可见对sexy back 的喜爱。

歌曲的MV大致讲的是JT与一个女特务之间的心理战。

_Sexy back_ 也是一种SM的暗号，意义为邀请xoxo，或者发出暗号。

另外，钟汉良2011年10月2日上海卢湾演唱会、香港歌手歌手林峯在2008年度香港小姐总决赛、杨宗纬Star!Start!星空传奇演唱会、亚洲时尚舞后ELVA萧亚轩在自己的WOW世界巡回演唱会中也翻唱过。

歌词下方是 _SexyBack钢琴谱_ ，希望大家喜欢。


text:
# neill's micro:bit neopixel-strip demos
A collection of microbit neopixel demos used at after-school clubs, coder dojos, and jams, to stimulate ideas.

Note that the focus with a demo is not as a code example for the kids.  Simpler examples of each demo, or at least its core concepts, will be prepared here, too, and marked with the suffix ...Example.js

* [2pRacerLEDs - 2player NeoPixel light-racing demo](2pRacerLEDs.md)
* [TugOfWarLEDs - 2player NeoPixel tug-o-war demo](TugOfWarLEDs.md)
* [Remote Light-Level to NeoPixel BarChart Demo](LightLevelBarChartLEDsTxRxPair.md)
* [SmoothRacerDemo - prototype smoother racing demo](SmoothRacerDemo.md)
* [ColourMatchInvadersLEDs - experimental colour-matching space-invaders](ColourMatchInvadersLEDs.md)

## Javascript on micro:bit?
These '.js' source files are from the makecode (javascript/block) editor for micro:bit.  To recreate these projects if an up-to-date .hex file or makecode project is not available, you'll need to make a new project on makecode, install the neopixel library, switch to javascript view, and paste the '.js' code from here.

#### Notes about GitHub Pages (for Neill)

* [GitHub Flavored Markdown](https://guides.github.com/features/mastering-markdown/).
* [repository settings](https://github.com/nbogie/neill-microbit-neopixel-demos/settings) (The name of this theme is saved in the Jekyll `_config.yml` configuration file.)
* [github pages documentation](https://help.github.com/categories/github-pages-basics/)

repository: nbogie/neill-microbit-neopixel-demos

repo_name: nbogie/neill-microbit-neopixel-demos


text:
---
layout: default
---

# 1995-08-03 - Re: Zimmermann legal fund

## Header Data

From<EMAIL_ADDRESS>(MONTY HARDER)

To<EMAIL_ADDRESS>Message Hash: 20c11ad93ea9a16af4acd5f03a2d838a0d7155c500cdc954a5c9c5cf1b31c090

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-08-03 04:04:34 UTC

Raw Date: Wed, 2 Aug 95 21:04:34 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(MONTY HARDER)
Date: Wed, 2 Aug 95 21:04:34 PDT
To<EMAIL_ADDRESS>Subject: Re: Zimmermann legal fund
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

MB> > an account that can be accessed over the net will be the day I close my US
MB> > accounts.
MB>
MB> Interesting idea ...
MB>
MB> 1st question or thing I would want to be certain of is the stability of the
MB> currency of the realm so to speak. I wouldn't want to bank in a country that
MB> had a weak currencey (sp) or was subject to roller coaster economics.

  Why would the currency of the country be relevant to the bank? There
is no reason why banks can not calculate balances in foreign currency. A
bank could even permit "vector balances" for accounts, such as:

                               <D, F, M, Y>

representing Dollars , (Swiss) Franks, Deutschmarks, and Yen,
respectively. One could even create a "synthetic currency" set to, say,
<.25, .4, .5, 30>, and all deposits and withdrawls would be converted
accordingly. This way, if one country blows things, you don't get hit
too hard.

  ObCrypto: Well... This will involve a bit more complicated arrangement
of finances, and add in the currency-conversion thing, so it will be
even more important to have standardized means of secure communications
with your offshore bank.

---
 *<EMAIL_ADDRESS>*

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(MONTY HARDER)](/authors/monty_harder_at_famend_com_monty_harder_)"

+ 1995-08-03 (Wed, 2 Aug 95 21:04:34 PDT) - Re: Zimmermann legal fund -<EMAIL_ADDRESS>(MONTY HARDER)_


text:
---
title: Other digital gardens and inspiration
---

* [Bismuth Garden](https://bismuth.garden) - like the concept of portals, different ways of exploring things. Reading now / have read page.
* [Personal Learning Path (Backend) - 20/11/2020 - notes.ajb.app](https://notes.ajb.app/notes/000218.html) - like the idea of a personal learning path - something to develop for myself?
* [Patterns - Gordon Brander](http://gordonbrander.com/pattern/) Lots of meaty topics in here. Sometimes feels a bit beyond me but I like the idea of a ‘bag of tricks’
* [Notes to Self](https://til.yenly.wtf) Simple and friendly digital garden. Public learning.
* [Learn In Public](https://www.swyx.io/learn-in-public/) -*make the thing you wish you had found*
* [2020 Book Recommendations](https://www.dschapman.com/articles/2020-book-recommendations)
* [Artificial brains](https://www.notion.so/Artificial-Brain-Networked-with-linear-notebook-app-a131b468fc6f43218fb8105430304709) - list of lots of resources and gardens
* [essays](https://www.patriciamou.com/essays) Blog rather than digital garden, with focus on wellness
* [What an amazing about page](https://sive.rs/about)
* [Buster Benson](https://busterbenson.com/piles/) Piles as a way of organising garden
* [Writing - Everything I know](https://wiki.nikitavoloboev.xyz/writing) I like the ideas and topics in this garden

filename: other digital gardens.md


text:
NodeJS Prometheus Wrapper [![CircleCI](https://circleci.com/gh/iadvize/nodejs-prometheus-wrapper.svg?style=svg)](https://circleci.com/gh/iadvize/nodejs-prometheus-wrapper)
===========================

Wrapper to official NodeJS Prometheus exporter ([prom-client](https://github.com/siimon/prom-client))

The official NodeJS client for prometheus requires to transporter the metrics variables in your code (counters, gauges, histograms and summaries).

This small library allow to control variables from the whole code, in a singleton, by getting the metric by name, just like that: ```require('prometheus-wrapper').get("<counter-name>").inc()```

## Examples

init.js

```javascript
var prometheus = require("prometheus-wrapper");

var express = require('express');
var app = express();

prometheus.setNamespace("myapp");

app.get('/metrics', function(req, res) {
  res.end(prometheus.getMetrics());
});

// Counter
prometheus.createCounter("mycounter", "A number we occasionally increment.");

// Gauge
prometheus.createGauge("mygauge", "A random number we occasionally set.");

// Histogram
prometheus.createHistogram("myhistogram", "A chat duration histogram.", {
	buckets: [ 10, 30, 60, 300, 600, 1800, 3600 ]
});

// Summary
prometheus.createSummary("mysummary", "Compute quantiles and median of a random list of numbers.", {
	percentiles: [ 0.01, 0.1, 0.5, 0.9, 0.99 ]
});

app.listen(8080);
```

wherever-in-your-code.js

```javascript
var prometheus = require("prometheus-wrapper");

setInterval(function () {
	prometheus.get("mycounter").inc(42);
}, 10000);

prometheus.get("mygauge").set(42);

var end = prometheus.get("myhistogram").startTimer();
setTimeout(function () {
	end();
}, 15000);

for (var i = 0; i < 100000; ++i) {
	prometheus.get("mysummary").observe(Math.random());
}
```

Exposed ```/metrics``` :

```sh
$ curl <IP_ADDRESS>:8080

# HELP myapp_mycounter A number we occasionally increment.
# TYPE myapp_mycounter counter
myapp_mycounter 84

# HELP myapp_mygauge A random number we occasionally set.
# TYPE myapp_mygauge gauge
myapp_mygauge 42

# HELP examples_myhistogram A chat duration histogram.
# TYPE examples_myhistogram histogram
myapp_myhistogram_bucket{le="10"} 0
myapp_myhistogram_bucket{le="30"} 1
myapp_myhistogram_bucket{le="60"} 1
myapp_myhistogram_bucket{le="300"} 1
myapp_myhistogram_bucket{le="600"} 1
myapp_myhistogram_bucket{le="1800"} 1
myapp_myhistogram_bucket{le="3600"} 1
myapp_myhistogram_bucket{le="+Inf"} 1
myapp_myhistogram_sum 15.002
myapp_myhistogram_count 1

# HELP myapp_mysummary Compute quantiles and median of a random list of numbers.
# TYPE myapp_mysummary summary
myapp_mysummary{quantile="0.01"} 0.009997170550270069
myapp_mysummary{quantile="0.1"} 0.09957970759409267
myapp_mysummary{quantile="0.5"} 0.5016970195079504
myapp_mysummary{quantile="0.9"} 0.8993228241841542
myapp_mysummary{quantile="0.99"} 0.9901868947762174
myapp_mysummary_sum 4999.807495853165
myapp_mysummary_count 10000
```

### Labels

Example:

```javascript
var prometheus = require("prometheus-wrapper");

// Init Counter
prometheus.createCounter("mycounter", "A number we occasionally increment.", ['foo']);

setInterval(function () {
	prometheus.get("mycounter").inc({foo: 'bar'}, 42);
	prometheus.get("mycounter").inc({foo: 'baz'}, 21);
}, 10000);

prometheus.get("mygauge").set(42);
```

```sh
$ curl <IP_ADDRESS>:8080

# HELP myapp_mycounter A number we occasionally increment.
# TYPE myapp_mycounter counter
myapp_mycounter{foo="bar"} 42
myapp_mycounter{foo="baz"} 42
```

## Install

```
npm install --save prometheus-wrapper
```

## Documentation

### Full list of metrics types

[Official documentation](https://prometheus.io/docs/concepts/metric_types/)

#### Counter
```
A counter is a cumulative metric that represents a single numerical value that only ever goes up. A counter is typically used to count requests served, tasks completed, errors occurred, etc. Counters should not be used to expose current counts of items whose number can also go down, e.g. the number of currently running goroutines. Use gauges for this use case.
```

#### Gauge
```
A gauge is a metric that represents a single numerical value that can arbitrarily go up and down.

Gauges are typically used for measured values like temperatures or current memory usage, but also "counts" that can go up and down, like the number of running goroutines.
```

#### Histogram

```
A histogram samples observations (usually things like request durations or response sizes) and counts them in configurable buckets. It also provides a sum of all observed values.

A histogram with a base metric name of <basename> exposes multiple time series during a scrape:

- cumulative counters for the observation buckets, exposed as <basename>_bucket{le="<upper inclusive bound>"}
- the total sum of all observed values, exposed as <basename>_sum
- the count of events that have been observed, exposed as <basename>_count (identical to <basename>_bucket{le="+Inf"} above)
```

#### Summary

```
Similar to a histogram, a summary samples observations (usually things like request durations and response sizes). While it also provides a total count of observations and a sum of all observed values, it calculates configurable quantiles over a sliding time window.

A summary with a base metric name of <basename> exposes multiple time series during a scrape:

- streaming φ-quantiles (0 ≤ φ ≤ 1) of observed events, exposed as <basename>{quantile="<φ>"}
- the total sum of all observed values, exposed as <basename>_sum
- the count of events that have been observed, exposed as <basename>_count
```

### Methods available

#### setNamespace

- ```client.setNamespace(<namespace>)``` => prefixes every metric name

#### getMetrics

- ```client.getMetrics()``` => what to expose in your server under /metrics

#### Counter

- ```client.createCounter(<name>, <help>, [ <label-list> ])```
- ```client.get(<name>).get()```
- ```client.get(<name>).inc()```
- ```client.get(<name>).inc(<delta>)```

#### Gauge

- ```client.createGauge(<name>, <help>, [ <label-list> ])```
- ```client.get(<name>).get()```
- ```client.get(<name>).set(<value>)```
- ```client.get(<name>).setToCurrentTime()``` => expose a timestamp in ms
- ```var end = client.get(<name>).startTimer()``` => call ```end()``` to stop the timer, expose a timestamp in seconds

#### Histogram
- ```client.createHistogram(<name>, <help>, buckets: [ <categories> ], [ <label-list> ])```
- ```client.get(<name>).get()```
- ```client.get(<name>).observe(<value>)```
- ```client.get(<name>).reset()```
- ```var end = client.get(<name>).startTimer()``` => call ```end()``` to stop the timer, expose a timestamp in seconds

#### Summary
- ```client.createSummary(<name>, <help>, buckets: [ <categories> ], [ <label-list> ])```
- ```client.get(<name>).get()```
- ```client.get(<name>).observe(<value>)```
- ```client.get(<name>).reset()```
- ```var end = client.get(<name>).startTimer()``` => call ```end()``` to stop the timer, expose a timestamp in seconds

## Contribute

Look at contribution guidelines here : [CONTRIBUTING.md](CONTRIBUTING.md)

repository: iadvize/nodejs-prometheus-wrapper

repo_name: iadvize/nodejs-prometheus-wrapper


text:
# Bluetooth I2C

Sensing, Recording, Sending -- in this project we'll send the data directly to you without a wired connection.

Using the Nordic nRF51822 BLE, we'll start connecting your sensor to your phone.

# Relevant Datasheet

https://www.nordicsemi.com/eng/Products/Bluetooth-Smart-Bluetooth-low-energy/nRF51822


text:
# Alerter

alerter is a command-line tool to send Mac OS X User Alerts (Notifications),
which are available in Mac OS X 10.8 and higher. (even catalina)
the program ends when the alerter is activated or closed, writing the activated value to output (stdout), or a json object to describe the alert event.

Alerts are OS X notifications that stay on screen unless dismissed.

2 kinds of alert notification can be triggered : "Reply Alert" or "Actions Alert"

## Reply alert
Open a notification in the top-right corner of your screen and display a "Reply" button, which opens a text input.

## Actions alert
Open a notification in the top-right corner of your screen and display one or more actions to click on.

## Features
* set alert's icon, title, subtitle, image.
* capture text typed by user in the reply type alert.
* timeout : automatically close the alert notification after a delay.
* change the close button label.
* change the actions dropdown label.
* play a sound while delivering the alert notification.
* value or json output on alert's event (closed, timeout, replied, activated...)
* close the alert notification on SIGINT, SIGTERM.

## Installation

1. Download the zipped precompiled binary from the
[releases section](https://github.com/vjeantet/alerter/releases).
2. Extract the binary.
3. Use as described below.

### Adding to `$PATH`

If you don't want to have to specify the absolute/relative path to the binary, you can place the binary in any directory that is listed in your `$PATH` so that your system can automatically find it.

If you would like to see which directories are currently in your `$PATH`, you can run `echo $PATH`.

You can use the `cp` command to copy the binary to your chosen directory. For example:

```shell
cp ~/Downloads/alerter /path/to/directory/you/choose/
```

## Usage

```
$ ./alerter -[message|group|list] [VALUE|ID|ID] [options]
```

Some examples are:

Display piped data with a sound

```
$ echo 'Piped Message Data!' | alerter -sound default
```

![Display piped data with a sound](/img1.png?raw=true "")

Multiple actions and custom dropdown list
```
./alerter -message "Deploy now on UAT ?" -actions Now,"Later today","Tomorrow" -dropdownLabel "When ?"
```

![Multiple actions and custom dropdown list](/img2.png?raw=true "")

Yes or No ?
```
./alerter -title ProjectX -subtitle "new tag detected" -message "Deploy now on UAT ?" -closeLabel No -actions Yes -appIcon http://vjeantet.fr/images/logo.png
```

![Yes or No](/img3.png?raw=true "")

What is the name of this release ?
```
./alerter -reply -message "What is the name of this release ?" -title "Deploy in progress..."
```

![What is the name of this release](/img4.png?raw=true "")

## Options

At a minimum, you have to specify either the `-message` , the `-remove`
or the `-list` option.

-------------------------------------------------------------------------------

`-message VALUE`  **[required]**

The message body of the notification.

Note that if this option is omitted and data is piped to the application, that
data will be used instead.

-------------------------------------------------------------------------------

`-reply`

The notification will be displayed as a reply type alert.

-------------------------------------------------------------------------------

`-actions VALUE1,VALUE2,"VALUE 3"`

The notification actions available.
When you provide more than one value, a dropdown will be displayed.
You can customize this dropdown label with the next option.
Does not work when -reply is used.

-------------------------------------------------------------------------------

`-dropdownLabel VALUE`

The notification actions dropdown title (only when multiples -actions values are provided).
Does not work when -reply is used.

-------------------------------------------------------------------------------

`-closeLabel VALUE`

The notification "Close" button label.

-------------------------------------------------------------------------------

`-title VALUE`

The title of the notification. This defaults to ‘Terminal’.

-------------------------------------------------------------------------------

`-subtitle VALUE`

The subtitle of the notification.

-------------------------------------------------------------------------------

`-timeout NUMBER`

Auto close the alert notification after NUMBER seconds.

-------------------------------------------------------------------------------

`-sound NAME`

The name of a sound to play when the notification appears. The names are listed
in Sound Preferences. Use 'default' for the default notification sound.

-------------------------------------------------------------------------------

`-json`

Alerter will output a json struct to describe what happened to the alert.

-------------------------------------------------------------------------------

`-group ID`

Specifies the ‘group’ a notification belongs to. For any ‘group’ only _one_
notification will ever be shown, replacing previously posted notifications.

A notification can be explicitly removed with the `-remove` option, described
below.

Examples are:

* The sender’s name to scope the notifications by tool.
* The sender’s process ID to scope the notifications by a unique process.
* The current working directory to scope notifications by project.

-------------------------------------------------------------------------------

`-remove ID`  **[required]**

Removes a notification that was previously sent with the specified ‘group’ ID,
if one exists. If used with the special group "ALL", all message are removed.

-------------------------------------------------------------------------------

`-list ID` **[required]**

Lists details about the specified ‘group’ ID. If used with the special group
"ALL", details about all currently active  messages are displayed.

The output of this command is a json array of alert notifications.

-------------------------------------------------------------------------------

`-sender ID`

Specifying this will make it appear as if the notification was send by that
application instead, including using its icon.

Using this option fakes the sender application, so that the notification system
will launch that application when the notification is clicked. Because of this
it is important to note that you cannot combine this with options like
`-execute`, `-open`, and `-activate` which depend on the sender of the
notification to be ‘alerter’ to perform its work.

For information on the `ID` see the `-activate` option.

-------------------------------------------------------------------------------

`-appIcon PATH` **[10.9+ only]**

Specifies The PATH or URL of an image to display instead of the application icon.

**WARNING: This option is subject to change since it relies on a private method.**

-------------------------------------------------------------------------------

`-contentImage PATH` **[10.9+ only]**

Specifies The PATH or URL of an image to display attached inside the notification.

**WARNING: This option is subject to change since it relies on a private method.**

-------------------------------------------------------------------------------

## Example usage with shell script
```bash
ANSWER="$(./alerter -message 'Start now ?' -closeLabel No -actions YES,MAYBE,'one more action' -timeout 10)"
case $ANSWER in
    "@TIMEOUT") echo "Timeout man, sorry" ;;
    "@CLOSED") echo "You clicked on the default alert' close button" ;;
    "@CONTENTCLICKED") echo "You clicked the alert's content !" ;;
    "@ACTIONCLICKED") echo "You clicked the alert default action button" ;;
    "MAYBE") echo "Action MAYBE" ;;
    "NO") echo "Action NO" ;;
    "YES") echo "Action YES" ;;
    **) echo "? --> $ANSWER" ;;
esac
```

## Support & Contributors

### Code Contributors

This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].

This project is based on a fork of [terminal notifier](https://github.com/julienXX/terminal-notifier) by [@JulienXX](https://github.com/julienXX).

## License

All the works are available under the MIT license.

Copyright (C) 2012-2023 Valère Jeantet<EMAIL_ADDRESS>Eloy Durán<EMAIL_ADDRESS>Julien Blanchard
<EMAIL_ADDRESS>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

repository: vjeantet/alerter

gha_language: Objective-C

repo_name: vjeantet/alerter


text:
# Pinboard

Pinboard is a web based application where registered users can login and add or delete notes on a shared pinboard. In the notes, users can put simple texts, pictures or files. Editing and changing the place of a note in a pinboard is allowed. All changes are reflected to all logged users in real time.

In this document the way to run the application and the code structure will be explained.

## Requirements and Instructions to Run

In this section, the requirements and instructions on how to run the application will be given.

The application has the following dependencies:

* Java 8 (the application does not run with Java 9 and not tested with later versions, this will be investigated in the future)
* MongoDB

MongoDB must be started before the server is running.

In the root folder of the repository, pinboard.war is the compiled version of the application and it can be run by the following command:

```
java -jar pinboard.war
```

When the server is ready to receive requests, the application can be accessed by URL **"http://localhost:7000/pinboard"**. It will redirect to the login page if the user is not logged in before.

Initially, there are two users: user1 (with password user1) and user2 (with password user2). This can be changed by editing src/main/java/project/pinboard/ServerApplication.java

## Usage

This is the initial screen when entering to **"http://localhost:7000/pinboard"**

It is just an empty page because there is no pinboard added before. To add a new pinboard, you can click to the **+** icon at the right-top of the page. Then, the page will appear as the following:

This way, a pinboard is created with title "NEW BOARD" and at the bottom of the title the icons of users which have the right to access to this pinboard are shown. Currently, only the user who created this pinboard has the right to access to it so only one icon is visible.

When hovering to the box, three icons will appear on the top (shown in the image above). They can be used to change the title, grant/remove access rights for users and delete the pinboard. The following is the appearance of the board after its title is changed and an access right is granted to another user (note that after this step, the board will appear on the main page of both users).

To go to the pinboard to see/add notes, double-click to the box. It will lead to the following page:

Currently, this page is empty as no user has added any postits. A new postit can be added by double-clicking to a place on the pinboard. Then the following popup will appear:

Here the size of a textbox can be changed and it can be deleted or moved. To do so, just click to the text and the border of the textbox will appear:

Then, it can be resized, deleted or moved. It is also possible to add a new text box. To do so, just double-click to an empty point, a new text box will appear.

It is also possible to add a picture in the note. It can be done by just dragging a picture file into the white part of the popup. Then picture can be resized, moved or deleted just in the same way with text boxes.

Finally, a file can be added to the note. To upload a file drag the file into the gray rectangle at the bottom of the popup. Currently, a file cannot be bigger than 20MB but this limit can be changed by updating application.properties file. This will be the appearance after uploading a file:

To remove the file, just hover into the box with the filename and press X button (the same way for removing textboxes and pictures). To add the note into the pinboard, click "Save". Then in the pinboard, a new postit should appear.

Now, any user which has the right to access this pinboard can see this postit. Note that in the postit, pictures are not appearing and only texts are visible. However, a user can double-click to the postit and see all the contents. After double-clicking the postit, a user can edit and see the postit if (s)he is the creator of it, otherwise it is read-only. Also, the files uploaded for this postit can be downloaded.

A postit can be deleted by its creator. To delete, just drag the pin of the postit to an empty space of the pinboard. After the left mouse button is released the postit will start falling down and disappear from the pinboard. In the picture below, you can see a postit to be deleted, its pin is dragged outside so it is to be removed from the pinnboard.

It is also possible to move a postit inside a pinboard and arrange the pinboard this way. Note that creation/removal/move of postits are reflected in real-time to all users who have the pinboard opened in their web browser.


text:
# MNIST classifcation Example

This example shows how you can use Tensorflow Lite micro to run a small 500
kilobyte fully connected MNIST classifier. It is intended to demonstrate the
minimal amount of code needed to export a model from a Tensorflow graph and
integrate
it into a Tensorflow lite micro. The classifier currently works with pre-loaded
test input used to validate the model, however if interfaced with a camera
module then this example could work in a real world application.

## Table of Contents
-   [Getting Started](#getting-started)
-   [Training and Exporting the Model](#training-and-exporting-the-model)

## Getting Started

To compile and test this example on a desktop Linux or MacOS machine, download
[the TensorFlow source code](https://github.com/tensorflow/tensorflow), `cd`
into the source directory from a terminal, and then run the following command:

```
make -f tensorflow/lite/micro/tools/make/Makefile
```

You only need to do this once, it will take a few minutes to download the
frameworks the code uses such as
[CMSIS](https://developer.arm.com/embedded/cmsis) and
[flatbuffers](https://google.github.io/flatbuffers/). Once that process has
finished, you can build the MNIST demo with the command below:

```
make -f tensorflow/lite/micro/tools/make/Makefile micro_mnist
```

This will have produced a native binary in the location:

```
tensorflow/lite/micro/tools/make/gen/<your platform>/bin
```

Executing this binary should produce the output below, testing and evaluating
the MNIST classifier on a set of compiled in test data:

```
Parsing MNIST classifier model FlatBuffer, size 83708 bytes.
Details of input tensor:
Type [FLOAT32] Shape :
0 [ 1]
1 [ 28]
2 [ 28]

Details of output tensor:
Type [INT32] Shape :
0 [ 1]

Model estimate [7] training label [7]
Model estimate [2] training label [2]
:
:
Model estimate [5] training label [5]
Model estimate [4] training label [4]
Test set accuracy was 96 percent

MNIST classifier example completed successfully.
```

This example code loads the MNIST classifier, logs the sizes and datatimes of
input and output tensors, then peforms 25 inferences on a set of baked in
test data. In the future this will be extended in the future with the addition camera input
pre-processing, so that the real world written numbers can be classified in
real time.

## Training and Exporting the Model

This demo includes the Tensorflow python project that was used to train the
model and export it in the format required by Tensorflow lite micro. This can
be found in
`examples/mnist_demo/model/mnist_train_and_export_to_tfl_micro.py`. This
script defines a simple 3 layer fully connected network, then trains it using
the MNIST dataset.

When this training is complete a TF lite flatbuffer is created containing the
network model, this is then saved as a `.cc` and `.h` file pair using the
function `write_tf_lite_micro_model()`. This is neccesary since the platforms
TFL micro targets do not have file systems, so the model needs to be compiled
directly into the binary.

Using these functions it is possible to setup a Makefile which will
automatically convert a protoBuffer model into the source files required by
TFL micro, fully automating the deployment process.


text:
---
layout: page
title: Mentors
permalink: /mentors/
---

Lambda Mentors are experienced software developers and (generally) regular participants
in the Lambda Lounge [http://lambdalounge.org] user group. They have contacts at several
organizations through their well-established professional and social networks. Mentors
are passionate about the field of software development, pursue technologies they love,
and want to give back to a community they have benefitted from participating in.

The Lambda Mentors program pairs each mentor with a learner. Mentors then provide learners
with a variety of professional guidance, which can range from pairing on a software project,
to providing book recommendations, to suggesting worthwhile conferences, to other activities
that enrich learners’ expanding understanding of computer science.

In return for sharing their valuable time and experience, Lambda Mentors facilitates donations
to a charity of the mentor’s choice. Lambda Mentors seeks out [sponsor
organization](/sponsors)
who agree to donate $50 to the charity of the mentor’s choice for
each hour of mentoring. In this way, mentors, while not compensated directly, can give back,
both through charitable contributions and through guiding the development of the learners
with whom they work.