text:
---
title: How to Build Learning Materials
category: Instructors
order: 2
---

Contents:
- [Academy Moments & Learning Materials](#learning-materials)
  - [Admission SLUs](#admission-slus)
  - [Bootcamp SLUs](#bootcamp-slus)
  - [Hackathon #1](#hackathon-1)
  - [Specializations 2-6](#specializations-2---6)
- [Deliverables](#deliverables)
  - [Learning Notebooks](#1-learning-notebook)
  - [Example Notebooks](#2-examples-notebook)
  - [Exercise Notebooks](#3-exercise-notebook)
  - [Bootcamp Presentation](#4-presentation-bootcamp-only)
  - [Hackathon problem](#5-hackathon-problem-statement-and-dataset)
  - [Hackathon Evaluation Guidelines](#6-hackathon-evaluation-guidelines)
  - [Hackathon Baseline Solution](#7-hackathon-instructor-baseline-solution)
- [Development process](#development-process)

---

This page should serve as the source of truth for how to develop any unit within the
academy. If you are not familiar yet with the main details about the course, start by checking
out more information [here](../../Starters Academy (LDSSA)/01-Starters-Academy-(Course).md)

Let's jump in!

# Learning Materials

The academy has different moments that require different learning materials. Typically
these divide into units and hackathons, with different deliverables. Each unit or
hackathon typically has one person allocated. This is the person
responsible by ensuring the delivery of all materials listed here. However, there
may be more contributors if necessary. An example of this is typically the hackathon
content, which most choose to collaborate on as a team.

### Admission SLUs

The admission Small Learning Units (SLUs) are the first contact students have
with the academy. They are designed as introductory material that students need
to tackle to get admitted into the academy. They are composed of:

* 1 [Learning Notebook](#1-learning-notebook)
* 1 [Examples Notebook](#2-examples-notebook)
* 1 [Exercise Notebook](#3-exercise-notebook)

### Bootcamp SLUs

The bootcamp SLUs are a set of small learning units that will be presented to
students during bootcamp. Each unit is composed of the same structure as the
admission SLUs and an additional 15 minute presentation

* 1 [Learning Notebook](#1-learning-notebook)
* 1 [Examples Notebook](#2-examples-notebook)
* 1 [Exercise Notebook](#3-exercise-notebook)
* 1 [Presentation](#4-presentation-bootcamp-only)

### Hackathon #1

The first hackathon is the only one detached from a specialization. It is typically a
simple binary classification problem where students can practice the base skills
that they learned during the bootcamp and have a first contact with the hackathon
structure. It is composed of:

* 1 [Problem statement and dataset](#5-hackathon-problem-statement-and-dataset)
* 1 [Evaluation Guidelines](#6-hackathon-evaluation-guidelines)
* 1 [Instructor Baseline Solution](#7-hackathon-instructor-baseline-solution)

### Specializations 2 - 6

The remaining specializations are longer and meant to be tackled throughout each month
of the academy by students. Each BLU is dimensioned so that it can be done within 1 week
and each hackathon is a moment for students to apply the methods they learned
throughout the specialization

* Big Learning Units (BLU)
  * 2-3 [Learning Notebooks](#1-learning-notebook)
  * 1 [Examples Notebook](#2-examples-notebook)
  * 1 [Exercise Notebook](#3-exercise-notebook)
* Hackathon
* 1 [Problem statement and dataset](#5-hackathon-problem-statement-and-dataset)
* 1 [Evaluation Guidelines](#6-hackathon-evaluation-guidelines)
* 1 [Instructor Baseline Solution](#7-hackathon-instructor-baseline-solution)

# Deliverables

We now list the different deliverables that are used across the academy.

### 1. Learning Notebook
The Learning Notebook will explain the materials in high detail. This notebook
should be mostly focused on **intuitions**, and provide motivations, visualizations,
and explain the new concepts in high granularity. It can and should work with examples
to showcase why the students are learning the new concepts. Don't worry too about
overlap with the Examples Notebook, as the Examples Notebook is mainly about common usage patterns.

**[Template Learning Notebook](https://github.com/LDSSA/bootcamp/blob/master/units/SLU06_Intermediate_Statistics/Learning%20notebook%20-%20SLU6%20(Intermediate%20statistics).ipynb)**

Expected time investment (1 learning notebook):

| Development | Instructor | Time (hours of investment) |
|---|---|----|
| Review and small fixes | Experienced instructor | 2 |
| Review and small fixes | Junior instructor | 4  |
| Review plus curriculum changes  | Experienced instructor | 8 |
| Review plus curriculum changes  | Junior instructor | 16 |
| Complete re-write / New unit from scratch | Experienced instructor | 24  |

Note: the times presented are indicative and refer to one single learning notebook
of average size. If a unit has multiple notebooks you should consider these times
multiplied by the number of units.

### 2. Examples Notebook

This will be extremely short, and look a bit like a cheatsheet of "common usage patterns". It can have
extra examples or applications of the content shown in the learning notebooks.

Expected time investment:

| Development | Instructor | Time (hours of investment) |
|---|---|----|
| Review/small changes | Any | < 1 |
| Complete re-write / New unit from scratch | Any | 2-4 |

### 3. Exercise Notebook

The exercise notebook is a sequence of exercises with auto-grading (see **[how to use nbgrader](https://ldssa.github.io/wiki/Instructors/03-Using-nbgrader-for-Exercise-Notebooks/)**
for details). This is where the students will try to apply the new concepts.
Your exercises should be focused on making sure students

1. interact with the concepts (often by simply copy-pasting some code from the Learning Notebook)
2. understand how to use the common code patterns (which they should have in the Examples Notebook).

Don't worry if the exercises seem absurdly easy, this is the first time the students interact with these concepts, so there's
no need to make things challenging for its own sake. The exercises notebook should contain only exercises, no explanations (it can have a quick
bit of context like a formula, as long as it is already in the Learning Notebook).

Expected time investment:

| Development | Instructor | Time (hours of investment) |
|---|---|----|
| Small exercise changes and reshuffle | Experienced instructor | 2 |
| Small exercise changes and reshuffle | Junior instructor | 8 |
| Overall narrative + exercise change | Experienced instructor | 16 |
| Overall narrative + exercise change | Junior instructor | 24 |
| New unit from scratch | Experienced instructor | 24  |

**[Template Exercise Notebook](https://github.com/LDSSA/bootcamp/blob/master/units/SLU06_Intermediate_Statistics/Exercise%20notebook%20-%20SLU6%20(Intermediate%20statistics).ipynb)** (with nbgrader)

### 4. Presentation (Bootcamp only).
The presentation should be **the same content** as the Learning Notebook, displayed in a friendly way.
Quite simply, you will be "pre-chewing" the material from the Learning Notebook, and giving it to the students
live on the day.

This means that during the bootcamp, the students will learn the concepts and intuitions from your presentation,
but not need to take notes, as the Learning Notebook already contains all the material in high granularity.
Presentations should not contain material which is not in the Learning Unit.

This also means that your presentation does not need to make sense without a presenter. There's no need to fill
the presentation with text, and can just have images to support what you are saying. Focus on making sure the
presentation is intuitive, engaging, motivating, and **fun**.

The presentation should be done using Google Slides, shared in anyone can view mode and it
should not take longer than 15 minutes. Your link should be to the presentation itself, not the full screen mode, so that
other people can clone it and change it. The presentation should be store under the
academy shared drive, which you will be given access when onboarded.

Expected time investment:

| Development | Instructor | Time (hours of investment) |
|---|---|----|
| Presentation | Experienced instructor | 4 |
| Presentation | Junior instructor | 8 |

#### What will happen in an bootcamp class (SLU)?
During the bootcamp, the sequence will be approximately the following:
> First 15 minutes: instructor goes through the presentation, and introduces new topics

> Minutes 15 to 20: students ask questions, instructor clarifies main points

> Last 40 minutes: students solve the exercises, using the Learning Notebook and Examples Notebooks for support.

As you might have noticed, there is no time dedicated to the students reading the
Learning Notebook. That is deliberate, as the same content has just been introduced in
a highly structured and (hopefully) entertaining way by the instructor. The student will,
however, need the Learning Notebook and Examples Notebook as support, as (s)he
tries to solve the Exercises.

### 5. Hackathon Problem Statement and Dataset

The hackathon **dataset** and **problem statement** consist of the
two deliverables that will be presented to students on the hackathon day, at the
end of a specialization. They are released on the day of the hackathon and have the
format described below:

* The dataset is a file or set of files provided directly in the repository containing
what we consider training data. We typically work with small to medium size datasets to
simplify the type of processing students need to do, given they work mostly on their own
computers. As such, you shouldn't need to exceed the size limitations that github imposes.
* The problem statement consists of a small narrative and a set of instructions that
indicates to students what is the task at end - what they are trying to predict and some
guidelines on how they are goign to be scored. This is typically shared through a public
link to a google document, provided in the README of the hackathon folder

Hackathons are a key moment in every specialization. They allow students to
put the skills they learned throughout the units in practice while working
together with other students. Working on different datasets and problems
gives students the opportunity to expand their knowledge beyond constrained
exercises, gaining practice that is as close as possible to a real life scenario.

For this purpose, when preparing a hackathon, you should try to keep the following
in mind:

1. The dataset should be real (extracted from a web source, for example), not fabricated
2. The problem should be as realistic as possible, this is, it could be something a data
scientist would do in real life
3. The data and problem should get a decent baseline using at least part or all of the
techniques taught in the specialization

Finally, building the dataset and problem statement involves more than that. It assumes you
already explored and tested out the dataset yourself (and potentially got more people to help)
so that you know what to expect from different techniques/splits/etc. This is something
that takes time, but is important to provide a solid hackathon, and a solid baseline solution (see
 [Instructor Baseline Solution](#7-hackathon-instructor-baseline-solution) below)

Expected time investment:

| Development | Instructor | Time (hours of investment) |
|---|---|----|
| Hackathon problem | Experienced instructor | 8 |
| Hackathon problem | Junior instructor | 16 |

### 6. Hackathon Evaluation Guidelines

An important part of the hackathon is to establish how students will be evaluated. This
evaluation will be mostly based on two factors:

* The score they achieve (based on the metric you defined in the problem) - worth 50%
* The presentation score, given by multiple instructors

The evaluation guidelines focus on the presentation, and are a set of factors and their
weights to help all instructors grade in a consistent and fair manner. They are usually
shared on a spreadsheet as a table, where each column is a parameter to evaluate
and each row will be a team.

Expected time investment:

| Development | Instructor | Time (hours of investment) |
|---|---|----|
| Evaluation guidelines | Experienced instructor | < 1 |
| Evaluation guidelines | Junior instructor | 2 |

### 7. Hackathon Instructor Baseline Solution

The final piece of the puzzle for a great hackathon is the baseline solution! This is meant to
help students revisit the hackathon and understand how to approach it. It is important to note
that, even though the solution doesn't have to be the best (or necessarily beat all students' scores)
it should be a **solid solution** by all measures of your specialization.

A great baseline solution usually has the following characteristics:

* Achieves a decent score on the problem - even if not the best, it should be better than a random
or naive approach to the problem
* Uses one or many of the techniques taught on the specialization - your solution should serve
as an example of the value of the methods students learned throughout the previous month
* Represents a well-structured and well-organized notebook - we want to provide examples of good
coding/development practices when using notebooks, showing the value of organized, reusable code

Expected time investment:

| Development | Instructor | Time (hours of investment) |
|---|---|----|
| Baseline Solution | Experienced instructor | 8 |
| Baseline Solution | Junior instructor | 16 |

# Development Process

For most of the specializations and units, the materials from previous batches
already have a high level of quality. Given that, our process assumes the
development will be done on top of the previous batch.

## Instructors repository

As mentioned in the [Teaching Process](../01-Teaching-process/), the Learning Units
are pushed to the [Academy GitHub](https://github.com/LDSSA/), to the repository with the
name format `batchX-instructors`. The README in the repository contains detailed
instructions around the batch process's technical aspects, such as branch naming, requirement,
etc.

Once the base improvements are done, the unit is shared with the QA team, which will
review and test the unit. This feedback helps us detect potential bugs and places for
improvement before the materials reach the students.

Recommended process whe adding units:

1. Open an issue and an associated PR to indicate the unit is being tracked and developed
2. Carefully read the scope of your learning unit in the [Curriculum repo](https://github.com/LDSSA/curriculum-development), and think about what the students should be able to do after they have finished
3. Go through the learning notebooks and check for anything that needs improvements
4. Google around and see how other people teach the concepts.
5. Submit the Learning Notebook and Example Notebook's improvements  to your PR
6. Go through the exercise notebook and define what you will change
7. Change the Exercise Notebook. Don't worry too much about auto-grader at first, you can do that later. Remember that students will do this very slowly, so if it doesn't seem absurdly easy, it's probably too hard.
8. Share with QA

Recommended execution order whe adding hackathons:
1. Open an issue and an associated PR to indicate the hackathon is being tracked and developed
2. Define the category of problem you think could be interesting to explore
3. Search for available datasets online that could fit your purpose
4. Explore the datasets and pick one that can make for an interesting challenge
5. Define which target variable students are predicting and create the file split that will
be shared with students
6. Create the google doc with the problem description
7. Link the document in the README, add the dataset and push to the PR
9. Create a set of notebooks that compose the instructor baseline. You can divide these into different
stages of the process, if you think it will make it easier for students to explore later. Explain why
your baseline is valid - it doesn't need to be the best solution, but it should be a reasonable solution
that uses the techniques taught in the unit
10. Create a separate PR and share the baseline solution with QA
11. Create the evaluation guidelines in a spreadsheet and share with QA in the PR description

repository: LDSSA/wiki

repo_name: LDSSA/wiki


text:
# [414. Third Maximum Number](https://leetcode-cn.com/problems/third-maximum-number/)

![](https://img.shields.io/badge/Difficulty-Easy-green.svg)

Topics

* [`Array`](https://leetcode.com/tag/array/)

Given an integer array `nums`, return *the **third distinct maximum** number in this array. If the third maximum does not exist, return the **maximum** number*.

**Example 1:**

```
Input: nums = [3,2,1]
Output: 1
Explanation:
The first distinct maximum is 3.
The second distinct maximum is 2.
The third distinct maximum is 1.
```

**Example 2:**

```
Input: nums = [1,2]
Output: 2
Explanation:
The first distinct maximum is 2.
The second distinct maximum is 1.
The third distinct maximum does not exist, so the maximum (2) is returned instead.
```

**Example 3:**

```
Input: nums = [2,2,3,1]
Output: 1
Explanation:
The first distinct maximum is 3.
The second distinct maximum is 2 (both 2's are counted together since they have the same value).
The third distinct maximum is 1.
```

**Constraints:**

 + `1 <= nums.length <= 10^4`
 + `-2^31 <= nums[i] <= 2^31 - 1`
 p

repository: InnoFang/algo-set

path: /LeetCode/0414. Third Maximum Number/README.md

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: InnoFang/algo-set


text:
---
layout: post
title:  "AI Weekly Reading Summary (28 September 2019)"
date: 2019-09-28 00:00 +0000
categories: artificial-intelligence
---

---
#### __1. Adversarial Examples Are Not Bugs, They Are Features__

__Source__: https://arxiv.org/abs/1905.02175

__Authors__: Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, Aleksander Madry

__Topics__: deep learning, adversarial examples

Adversarial examples -- inputs that are slightly perturbed by an imperceptible noise but causing weird behaviour in machine learning models -- have received a great attention, especially since its appearance in the context of deep learning ([Szegedy et al. 2013](https://arxiv.org/pdf/1312.6199.pdf), [Goodfellow et al. 2014](https://arxiv.org/pdf/1412.6572.pdf)).
The impact of such examples has also been studied in some previous work ([Dalvi et al. 2003](https://dl.acm.org/citation.cfm?id=1014066),[Globerson and Roweis 2006](1143889)).
The figure below shows one example of adversarial examples including its unintended behaviour.

{: style="text-align: center;"}
**The effect of adversarial noise**
{: style="font-size: 80%; text-align: center;"}

To alleviate such a behaviour, some solutions have been proposed, which mainly focus on building more robust models against the adversarial examples ([Madry et al. 2018](https://arxiv.org/pdf/1706.06083.pdf), [Stutz et al. 2019](http://openaccess.thecvf.com/content_CVPR_2019/papers/Stutz_Disentangling_Adversarial_Robustness_and_Generalization_CVPR_2019_paper.pdf))-- the solutions theirselves now have a name called *adversarial training*.
The assumption held by those work is that adversarial examples will disappear if better algorithms and larger scale data are available.

This paper provides a new perspective on why adversarial examples arise in the first place.
The main observation in this work is the existence of the so-called "non-robust features", which directly attribute to adversarial examples.
__Non-robust features__ are defined as those that are highly predictive, yet brittle and incomprehensible to humans, as opposed to __robust features__, i.e., highly predictive and also human comprehensible.

This work captures the non-robust features within a theoretical framework and also finds their empirical evidence on a range of image datasets.
The way to find was conducted by disentangling robust and non-robust features via an optimization that results in two separate datasets: robust dataset $$\mathcal{\hat{D}}_R $$ and non-robust dataset  $$ \mathcal{\hat{D}}_{NR}$$.

One interesting outcome from this work is that a classifer trained on the robust dataset $$\mathcal{\hat{D}}_R $$ through *standard training* can already reach a certain level of robustness, i.e., having a good adversarial performance.
Additionally, non-robust datasets are found to be sufficient to produce good standard generalisation tests, but suffer from adversarial tests.
The following figure succinctly summarizes the fore-mentioned outcomes.

{: style="text-align: center;"}
**Robust vs non-robust features with respect to the standard and adversarial training**
{: style="font-size: 80%; text-align: center;"}

#### __2. Billion-scale Commodity Embedding for E-commerce Recommendation in Alibaba__

__Source__: https://arxiv.org/pdf/1803.02349.pdf

__Authors__: Jizhe Wang, Pipei Huang, Zhibo Zhang, Binqiang Zhao, Huan Zhao, Dik Lun Lee

__Topics__: recommender system, graph embedding

Recommender System (RS) is perhaps one of the most widely used AI applications on the Internet these days.
It plays a central role in many business products, especially e-commerces.
This paper proposes an RS solution for Taobao, the largest customer-to-customer (C2C) platform in China to date, that attempts to address three challenges: scalability, sparsity, and cold-start.

In general, the overall system has two stages: 1) matching and 2) ranking.
This paper focuses on addressing the challenges in the matching stage, where the core task is the computation of pairwise similarities between all items based on users' behaviors.
Such a computation utilizes an embedding derived from graph, namely Base Graph Embedding (BGE), that serves a similar goal as the standard collaborative filtering (CF) based methods but offers higher-order similarities between items.

The graph $$ \mathcal{G} = (\mathcal{V}, \mathcal{E}) $$ is constructed from the behavior history of one billion users within a session or time window, which is one of the main contributions of this paper.
The nodes of the graph represent the items, where each edge is weighted by the co-occurences of the two connected items in all users' behaviors.
The constructed graph is then used to generate the samples of item sequences based on random walk.
The actual embedding is created through the Skip-gram model ([Mikolov et al. 2013](https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf)) learned from the samples from random walk.
The latter steps are adopted from DeepWalk ([Perozzi et al. 2014](http://www.perozzi.net/publications/14_kdd_deepwalk.pdf)).
The figure below illustrates the Base Graph Embedding process.
Furthermore, the BGE is also enhanced by incorporating side information, e.g., category, shop, price, etc, of an item, to reduce the cold-start problem.

{: style="text-align: center;"}
**Base Graph Embedding**
{: style="font-size: 80%; text-align: center;"}

The overall system was evaluated both in offline (on the link prediction task) and online (under A/B testing framework) fashions.
The experiments show the superiority of the BGE based RS over the existing systems.

#### __3. Greedy InfoMax for Biologically Plausible Self-Supervised Representation Learning__

__Source__: https://arxiv.org/pdf/1905.11786.pdf

__Authors__: Sindy Lowe, Peter O'Connor, Bastiaan S. Veeling

__Topics__: deep learning, self-supervision, greedy layerwised training

Modern deep learning models typically rely on the end-to-end supervised training via back-propagation.
There are at least two concerns arising with that approach.
Firstly, it is considered to be not quite biologically plausible.
Secondly, which is more important for practical purposes, it normally needs a large amount of labeled data to train a powerful model.
We all know that labeled data can be expensive to obtain.

This paper proposes a novel algorithm to train a deep neural network in a local, self-supervised mode, referred to as Greedy InfoMax (GIM).
That is, the model is trained in a greedy, modular fashion, i.e., training one module at a time through a self-supervision loss namely InfoNCE loss, adopted from Contrastive Predictive Coding (CPC) ([Oord et al. 2018](https://arxiv.org/abs/1807.03748)).
Such a modular training is considered to be more biologically plausible ([Linsker 1988](http://www.romanpoet.org/223/Linsker.SelfOrg.pdf), [http://www.romanpoet.org/223/Linsker.SelfOrg.pdf], [Palmer et al. 2015](https://www.pnas.org/content/112/22/6908)).
Furthermore, the self-supervision means that the model does not require labeled training data to construct useful representations.

The experiment results show that GIM provides even better accuracy than the fully supervised back-propagation on the STL-10 object classification task.
The accuracy is virtually similar to CPC, except that GIM trains the network module by module, which offers a practical benefit, i.e.,.
decreasing the memory costs during training.
The similar trend of outcomes also can be obseved on the audio classification tasks.

{: style="text-align: center;"}
**GIM evaluation on STL-10 dataset**
{: style="font-size: 80%; text-align: center;"}

license: Unlicense

extension: markdown

gha_language: CSS


text:
# Motivation
_Describe cases that motivate the implementation of the expected behavior._

# Expected behavior
_Describe how the feature should work._

# Actual behavior
_Describe the actual behavior of the feature or remove this section if the feature has not been implemented yet._

license: MIT

repository: singi/astring

repo_name: singi/astring


text:
# OpenEBS Addons for D2iQ Ksphere

This repository contains the OpenEBS addons needed to bootstrap [D2iQ Kubernetes](https://d2iq.com/solutions/ksphere).

## Overview

The structure of this repository follows the [Kubeaddons Catalog Documentation](https://github.com/mesosphere/kubeaddons/blob/master/tools/catalog/README.md) in reference, and uses the [Addon Revision concept covered therein](https://github.com/mesosphere/kubeaddons/blob/master/tools/catalog/README.md#special-addonrepository-options---addon-revisions).

You will find the following directories here:

* `addons/` - containing the actual manifests for addon resources
* `deployments/` - containing the default addons depending on the Kubernetes version
* `metadata/` - containing static metadata for the addons in `addons/`
* `test/` - containing integration tests for the addons in `addons/`

repository: muratkars/ksphere-addons

repo_name: muratkars/ksphere-addons


text:
## PoE Pallet

<small>based on substrate-pallet-node:  97eecd64d3324805acc411ae7e12398ca59915b2</small>

To do:

- [ ] Documentation inline & readme
- [ ] Tests
- [ ] Dual Token/Currency gas/(optional) fee payment and gas, fee routing to validator, dock (burn) addresses, respectively
- [ ] Move to a Pallet repo with paired substrate node(s) ?
- [ ] Limits, extensions

Note to self: Faucet with DOCK preference

### Overview
* PoE, Anchoring, Revocation, And Suspension
* Authorized accounts to revoke leafs, init suspensions

#### Anchoring
1. Data/Digest
2. Revocation bool

#### Revocation
1. Anchor
2. Leafs

#### Suspension

repository: docknetwork/poe

gha_language: Rust

repo_name: docknetwork/poe


text:
# `CommServer` software Migration and Maintenance

This project is aimed at `CommServer` software migration from on-premise subversion repository to GitHub and publishing it as the Open-source software (OSS). OSS is a type of computer software in which source code is released under a license in which the copyright holder grants users the rights to study, change, and distribute the software to anyone and for any purpose.

The project will be used to manage the migration process of transferring multi-parts software from an on-premise subversion repository to a set of GitHub repositories.

After migration, this project will aggregate the description of all activities addressing the software maintenance process.

## About `CommServer`

`CommServer` is a package of software to manage data transfer. Built-in technologies and algorithms provide a smart data transmission that automatically adapts its parameters to the process needs and underlying communication network capabilities.

To learn more about `CommServer` software family visit the [software home page][comsvr].

The `CommServer` software was written by CAS Lodz Poland. I am the founder and Executive Director of CAS. Now CAS is just an individual business activity conducted by me, so I decided to move this software to Open Source.

## Migration Scope

- [x] [Address Space Model Designer](http://www.commsvr.com/Products/OPCUA/UAModelDesigner.aspx)
- [ ] [Process Observer](http://www.commsvr.com/Products/OPCUA/CommServerUA.aspx)
  - [ ] communication engine used by OPC servers
  - [ ] configuration tool
  - [ ] monitoring tool
- [ ] [OOI Reactive Application]() (PubSub) configuration editor
  - etc.

## Releases

We use [Semantic Versioning](http://semver.org/) for versioning. For the versions available, see the [releases on this repository](https://github.com/commsvr-com/migration2os/releases). For your convenience, the versions of the tools and NuGet packages making up the `CommServer` software has been listed in the next subsections.

### Tools

The table below lists the latest versions of the published Tools.

| Description | Version |Source|Installer|Date|
|-------------|:-------:|------|------------|----|
|Address Space Model Designer (ASMD) |3.20.1|[mpostol/ASMD](mpostol/ASMD)|[Windows installation released by CAS](http://www.commsvr.com/COInstal/UAModelDesignerPro/setup.exe)|May 17, 2016|

### NuGet packages

The table below lists the published NuGet packages.

| Package Id  | Description | Source |
|-------------|-------------|:------:|
[CAS.CodeProtec](https://www.nuget.org/packages/CAS.CodeProtect/) |Helper library supporting licenses creation and validation.| [mpostol/CodeProtect](https://github.com/mpostol/CodeProtect)
[CAS.RealTime][asmdn]|Real-Time Programming Helpers Library. |[mpostol/RealTime](https://github.com/mpostol/RealTime)
[CAS.CommServer.DA.Client][asmdn] | Provides set of assemblies that may be used by the OPC DA Clients. | NA|
[CAS.CommServer.DA.Viewer][asmdn]|CommServer OPC Viewer is a full featured OPC client designed to help during installation, testing, and configuration of OPC Data Access compliant servers. This tool is available as standalone or included in the other software packages.|NA
[CAS.CommServer.DAClientConfiguration][asmdn]|Library supporting OPC Classic Configuration management functions.|NA
[CAS.CommServer.DAServerConfiguration][asmdn]|Server Configuration Management Library provides CAS.NetworkConfigLib namespace.|NA
[CAS.CommServer.DeviceSimulator][asmdn]|Device Simulator for CommServer family.|NA
[CAS.CommServer.OPCClassic.SDK.COMWrapper][asmdn]|The COM Wrapper library for OPC Classic .NET API based on OPC Foundation SDK 2.01.106.|NA
[CAS.CommServer.OPCClassic.SDK.Core][asmdn]|The Core library for OPC Classic .NET API based on OPC Foundation SDK 2.01.106.|NA
[CAS.CommServer.UA.ConfigurationEditor.ServerConfiguration][asmdn]|This plug-in is used to configure the CAS OPC UA CommServer and define bindings of the model instance nodes with the actual real-time process data source.|NA
[CAS.CommServer.UA.ModelCompiler.Command][asmdn]|The Model Compiler generates UANodeSet, C# and ANSI C source code from XML files which include the UA Services, data-types, error codes, etc.; and numerous CSV files that contain NodeIds, error codes, and attributes etc. To be used as a plug-in by the CAS Address Space Model Designer.|NA
[CAS.CommServer.UA.ModelCompiler.Common][asmdn]|OPC UA ModelCompiler common part separated form the CAS.CommServer.UA.ModelCompiler to provide the standard model.|NA
[CAS.CommServer.UA.Stack.Core][asmdn]|OPC UA Stack provided by OPC Foundation and refactored by CAS.|NA
[CAS.Licenses.Container][asmdn]|Is deprecated and will be removed from the dependence's chain|NA
[CAS.MAML.HelpTopics.Content][asmdn]|Library containing schema definition of the all topics xml file.|NA
[CAS.UA.Common][asmdn]|The library contains a shared helpers used to process OPC UA data. It contains Types definition and serialization classes.|NA
[CAS.UA.IServerConfiguration](https://www.nuget.org/packages/CAS.UA.IServerConfiguration/)|The CAS.UA.IServerConfiguration library contains a shared interfaces for server configuration which UA applications can reference.The library provides an abstraction over any OPC UA server configuration plug-in. Using the library allows an application to indirectly access the server configuration attributes without relying on hard references. The hope is that using this library, third-party applications and frameworks can begin to leverage server configuration management without tying themselves down to a specific implementation.|[mpostol/OPC-UA-OOI](https://github.com/mpostol/OPC-UA-OOI)
[CAS.Windows.Forms][asmdn]|The library contains Windows.Forms controls.|NA

## Read more

- [Object Oriented Internet - C# deliverables supporting a new Machine To Machine (M2M) communication architecture; GitHub repository][OOI]
- [OPC UA Address Space Model Designer;GitHub repository](ASMD)
- [CommServer - Home Page][comsvr]
- [CAS Lodz Poland Home Page][CAS]
- [WIKI of this project](https://github.com/commsvr-com/migration2os/wiki)
- [My Blog: About enablers of future solutions](http://wwww.mpostol.wordpress.com/)
- [About me on LinkedIn](https://pl.linkedin.com/in/mpostol)
- [OPC Foundation](https://opcfoundation.org/)
- [Contributing](https://github.com/commsvr-com/migration2os/blob/master/CONTRIBUTING.md)

[CAS]:http://www.cas.eu/
[comsvr]:http://www.commsvr.com/
[asmdn]:https://github.com/mpostol/ASMD/tree/master/_nugets
[OOI]:https://github.com/mpostol/OPC-UA-OOI
[ASMD]:https://github.com/mpostol/ASMD

<?-

## Content

### Architecture

The repository workspace are organized as it is illustrated in the Figure below.

TBD

## How to Contribute

TBD

-->

gha_license_id: MIT


text:
react-cursor
===============

> Functional state management abstraction for use with Facebook React

[react-cursor hello-world in a fiddle](https://jsfiddle.net/dustingetz/n9kfc17x/)

`react-cursor` helps you write stateless React components, and achieve optimizied React rendering.

 * Decouple your application state from the shape of the DOM, allowing application state to be normalized
 * easy shouldComponentUpdate implemented using reference equality
 * Designed for recursive or deeply nested data

Cursors do not make an app stateless, but they let an app keep all its state in a single place at the root -- thus the root is stateful, and all downtree views are stateless. So cursors are a tool for reducing the surface area of code that is stateful.

If you are already using immutable datastructures (like ImmutableJS), react-cursor is not for you. react-cursor uses regular javascript datastructures, and leans on [React's Immutability Helpers](https://facebook.github.io/react/docs/update.html) (sugared by [update-in](https://github.com/dustingetz/update-in/) to provide efficient immutable operations and structure sharing.

## Project Maturity
master is stable, there is a full test suite. See package.json for latest published snapshot and *npm install it with explicit version*. 2.0 is fully backwards compatible with 1.x.

## tutorial
New tutorial coming soon. for now see [react-cursor hello-world in a fiddle](https://jsfiddle.net/dustingetz/n9kfc17x/).

## API
`Cursor` has these methods:
 * value() - return the value in the cursor (cursors have value semantics, for compatibility with React lifecycle methods)
 * refine(key, ...keys) - return a new cursor nested inside the root cursor at some path
 * swap(f) - apply f with the refined value and puts returned value into the backing store

Cursor has non-core convienence methods:
 * set(v), merge(v), push(xs), unshift(xs), splice([[splices]]) - convenience wrappers for swap for common updates

There is a mixin `ImmutableOptimizations()` to achieve optimized rendering (yes, we also work with PureRenderMixin if you prefer that). See examples/helloworld for usage.

There are two constructors
 * build(reactCmpReference) - construct cursor backed by react state
 * build(rootValue, rootSwap) - construct cursor backed by state stored somewhere else

**state is stored in a stateful react component at the top level of react view-tree**
```javascript
var Store = React.createClass({
  getInitialState () { return {a: {b: 0}}; },
  render () {
    var cur = Cursor.build(this);
    return <App cursor={cur} />;
  }
});

React.render(<Store />, domEl);
```
This is the most common use case and the easiest migration path if you're already using react component local state and just want to hoist all your state to the root and not change any other code.

**state is stored in an [atom](https://github.com/cjohansen/js-atom) - works in large hybrid legacy apps like Rails with Turbolinks**
```javascript
var store = atom.createAtom({ a: { b: 0 } });

function render(key, ref, prevVal, curVal) {
  var cur = Cursor.build(curVal, store.swap);
  React.render(<App cursor={cur} />, domEl);
}

store.addWatch('react-renderer', render);
render('react-renderer', store, undefined, store.deref()); // Render the first time
store.removeWatch('react-renderer');
```
This works great in legacy page based apps that aren't pure React, since we can start and stop react rendering without losing state. This is important when our app uses more than one rendering technology. Our state is decoupled from React, so different parts of app can be coded differently but still share application state. For example, rails with TurboLinks where only one of the pages renders with React and the rest use Rails views.

**state is stored in a javascript var**
This is like using an atom but dumber - just a thought experiment to demonstrate the interface. Don't do this.
```javascript
var store = { a: { b: 0 } }; // store is just a var

function swap (f) {
  var prev = store;
  store = f(prev);
  render(prev, store); // render if the var changes
}

function render(prevVal, curVal) {
  var cur = Cursor.build(curVal, swap);
  React.render(<App cursor={cur} />, domEl);
}

render(undefined, store); // Render the first time
```

## demo app

Cursors are a recursive data structure, so we can implement recursive things like a JSON editor:

[![live demo](screenshot.png?raw=true)](http://master-xmc9sn4ypn.elasticbeanstalk.com/app/)

Here is the [live demo](http://master-xmc9sn4ypn.elasticbeanstalk.com/app/) (includes webpack sourcemaps), and [source code to the live demo](https://github.com/prognostic-llc/react-json-editor-example).

## Warnings, gotchas, more details, FAQ
 * don't mutate values that come out of a cursor, treat the values as immutable and use the cursor interface for updates
 * only store associative data structures in cursors (arrays, maps, values) - no functions (see issue #19)

Advantages of react-cursor over immutable-js, baobab, cortex:
 * Cursors are immutable and have value semantics; they can be used directly in react lifecycle methods
 * simpler types: use regular js data structures, don't need to convert back and forth between special data structures
 * easy to integrate with your existing large codebase already using react state
 * simpler implementation: tiny api, not much code

## License

_`react-cursor` is governed under the MIT License._

repository: danielmiladinov/react-cursor

repo_name: danielmiladinov/react-cursor


text:
---
title: 'Here my "Uses Page"'
path: '/blog/here-my-uses-page'
category: speaking
tags: [corkerspace, coworking, talks, freelancers, freelancersDay, digital nomads]
published: true
date: '2020-01-22'
featuredImage: './images/uses.tech banner.png'
---

## The initiative

This Monday (2020-01-20), listening to [Syntax.fm](https://syntax.fm/show/215/hasty-treat-picking-the-stack-for-uses-tech-gatsby-react-context-styled-components) I hear about the [Wes Bos](https://wesbos.com/)' [uses.tech](https://uses.tech/) initiative, something I see more and more in developers profiles and I found very useful to get good ideas of tools people found in their daily work.

## Why I joined to the idea

I play the guitar since I was 10 years old, and in bands from the '00s, and I remember copying our favourites bands gears and configurations in a page called [Guitargeek](https://web.archive.org/web/20170420231024/https://www.guitar.com/) (no longer online) when I was finding my sound.

So when I saw the initiative created, I got in love with the idea to apply it to our tools as developers, and I found both `uses.tech` and each `/uses` pages super interesting to see what people are using and get improvement ideas.

## Here you have mine

So I created my [/uses](/uses/), adding not only "Hardware" but the pieces of software and technology I use daily and after years of usage, I found it worth to keep in my workflow.

Feel free to visit [it and hopefully get some ideas](/uses/)

repository: robertovg/robertovgGatsbyjs

gha_language: JavaScript

repo_name: robertovg/robertovgGatsbyjs


text:
#### Port of Chase NES game, originally written by Shiru (Public Domain)

This game initially was written in the C programming language, which makes\
porting to PC is almost trivial with minimum changes.

Now game works as follow:\
        For music and sound effects it uses SDL2_Mixer instead of APU.\
        For graphics - [P3](https://github.com/kdv1/p3.git), simple PPU emulator.\
        For displaying and input - SDL2.\
        For low-level things - minimal port of neslib.\
        For stable fixed 60 fps - vsync

Purpose of this project is to debug P3 and create working demo.

Controls (Keyboard):\
        Up: W\
        Down: S\
        Left: A\
        Right: D\
        Select: Space\
        Start: Enter\
        A (not used in game): L\
        B (not used in game): K\
Toggles:\
        Red color tint: R\
        Green color tint: G\
        Blue color tint: B\
        Grayscale mode: C\
        Wave raster effect: E\
        Mapper test: M\
        Autofix y position of sprites: Y

Building with Visual Studio 2008:\
        Place dependencies to 'lib' folder (SDL2, SDL2_Mixer, P3 header file\
        with .lib files), open and build solution file in 'build/vs2008'.


text:
---
layout: post
title: 8x8
---

Businessmodel of 8×8
---------------------

### Customer Segments

8x8 has a niche market business model, with a specialized customer segment. It primarily operates in the cloud communications and collaboration services, a market in which the North American spending is expected to increase at a CAGR of 29% to US$14 billion in 2021. In this market, the company caters to a range of business customers, including SMBs and mid-market & larger distributed enterprises.

It serves 45,000 customers operating in over 100 countries across six continents, and has become the industry’s leading provider of secure, reliable enterprise cloud communications solutions.

8x8’s offerings are uniquely positioned to serve businesses of all sizes and can easily scale up, globally distributed enterprise customers. Its turnkey solution spans the breadth of communications and collaboration needs, provided with industry-leading reliability at an affordable cost. This allows customers to focus on their business instead of managing the complexities of disparate communications and collaboration platforms and the integration of these platforms with other cloud-based business applications.

### Value Proposition

8x8’s value proposition lies in helping enterprises solve critical challenges facing businesses today through increased customer satisfaction and loyalty, effective collaboration and communication, freeing up IT resources, with maintenance-free communications and easy deployment and unifying communications throughout the entire enterprise.

It also creates value for enterprises by integrating mobile devices such as smartphones, tablets and laptops into the communications strategy, viewing real-time and historical data about crucial business functions for faster, better decisions and by keeping costs low and productivity high, with one easy-to-use economical system.

This offers its clients security and compliance, reliability backed by exceptional customer support and performance assured services with a global presence and network.

### Channels

The company markets its services directly to end users through a variety of means including search engine marketing and optimization, third party lead generation sources, industry conferences, trade shows, webinars, traditional advertising channels and other demand generation activities.

It employs a multi-tiered direct sales force and indirect channel partner network consisting of VARs (value added resellers), master agents, system integrators and service providers in the U.S., Canada, UK and Australia to identify, qualify and manage prospects throughout the sales cycle.

The company’s sales professionals work closely with inside technical support, sales engineers and deployment specialists to develop customized proposals based on individual customer requirements.

### Customer Relationships

8x8 lays special emphasis on customer service, quality and building strong relationships. Its solutions have been designed to allow users to communicate and collaborate with others in an integrated and fluid manner. Also, its cloud software solutions encompass all of the primary communications capabilities required by businesses - voice, video, presence, chat, conferencing, collaboration, contact center and analytics - providing multiple buying paths and usage scenarios for customers.

The company’s solutions link customer information with internal collaboration capabilities to provide synchronized customer engagement. It has also released a series of analytic tools in 2016 that give businesses visibility into employee communications in the contact center and the enterprise.

8x8 serves its customers via a global reach to 114 countries. Moreover, it also maintains a call center in San Jose, California and have a staff of ~90 employees and contractors that provide customer service and technical support to customers.

### Key Activities

8x8 Inc provides cloud-based, enterprise-class software solutions that transform the way businesses communicate and collaborate globally.

The company's integrated, ‘pure-cloud’ offering combines global voice, conferencing, messaging and video with integrated workflows and big data analytics on a single platform.

### Key Partners

The company has telecommunications interconnect and service agreements with VoIP providers and PSTN telecommunications carriers, such as Level 3 Communications, Verizon Communications and Inteliquent.

### Key Resources

8x8 has been awarded over 120 US patents since its inception and has several more in its pipeline which is a key resource to the company. In addition, the company heavily relies on its 810 employee’s workforce for running its R&D, marketing and other key activities.

8x8's twelve data centers across eight locations around the world is also a valuable resource for day to day running.

### Cost Structure

8x8's main cost consist primarily of personnel related expenses which includes deployment engineering, costs associated with outsourced customer service call center operations, commissions and other marketing and promotional expenses.

Other significant costs include expenses related to the services purchased and the technology licensed from 3rd party carriers.

Due to the industry that the company operates in, 8x8 makes significant investments in research and development to keep itself at pace with rapid technological changes and advancements.

### Revenue Streams

8x8's core offering of cloud communication software solutions is the main contributor to its revenue and remains its main focus area for the future.

The company also generates revenues from the sale of its IP telephones for providing its cloud telephony service.


text:
# DashButtonCustom

![Alt Text](https://media.giphy.com/media/fRxuyRefpzxEOh5Dul/giphy.gif)

Requirements

iOS 9.3+
xCode 10

Installation

Cocoa Pods
pod 'DashButtonCustom', :git => 'https://github.com/MauroJuliano/DashButtonCustom.git'

Usage

Storyboard
Create a new UIButton in your storyboard.

Set the class of the UIButton to CustomButtonController in your Storyboard or nib.

 Obs:

This pod was created for study purpose only
License
DashButtonCustom is available under the MIT license. See the LICENSE file for more info.

repository: MauroJuliano/DashButtonCustom

branch_name: refs/heads/main

repo_name: MauroJuliano/DashButtonCustom


text:
## Selenium install
pip3 install selenium

## HOWTO install Chromedriver for selenium
Download correct chromedriver for chrome version from:
https://chromedriver.storage.googleapis.com/index.html

Instead of "~/chromedriver" Unpack your chromedriver and use the path to the file.
sudo mv -f ~/chromedriver /usr/local/bin/chromedriver
sudo chown root:root /usr/local/bin/chromedriver
sudo chmod 0755 /usr/local/bin/chromedriver

OBS!
It's required to have the geckodriver in an excecutable path, modify this command to fit your system:
export PATH=$PATH:/usr/local/bin/chromedriver

May be needed to give excecutionrights (may have to be in the directory):
chmod +x geckodriver

repository: AlbinSidas/FlowChart

repo_name: AlbinSidas/FlowChart


text:
# Sorting an array in Javascript

You can easily sort an array in Javascript by usign the ```sort``` function.

```
[3, 1, 2].sort() //Will give you [1, 2, 3]
```

You can also specify a compare function

```
const compare = (a, b) => {
  if (a < b) {
    return -1;
  }

  if (a > b) {
    return 1;
  }

  if (a == b) {
    return 0;
  }
};

[3, 1, 2].sort(compare);
```

You can find more about the meaning of -1, 0, 1 here: [MDN - sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)

repository: marcurares/learn

repo_name: marcurares/learn


text:
![](docs/cocytus.jpg)

Do you tarnish your Clojure with the occasional hint of Java?  Have you become indescribably tired of reloading your REPL every time you change anything with a `.java` suffix?  Look no further.

In your `project.clj` or `~/.lein/profiles.clj`, add this:

```clj
{:plugins [[lein-virgil "0.1.9"]]}
```

Now, as if by magic, every time the `.java` files on your `:java-source-paths` change, they will be recompiled within your REPL and all the namespaces that rely on those files will be reloaded.  A helpful message will be printed out, including any compilation errors you may have introduced along the way (these are written to `stdout`, so they may show up in a different buffer than your REPL).

Happy tarnishing.

### Boot

For [Boot](http://boot-clj.com/), add this to your `build.boot`:

```clj
(set-env! :dependencies '[[virgil "0.1.9"]
                          ...])

(require '[virgil.boot :refer [javac*]])
```

Now you have the option to run Virgil manually from the REPL. Virgil will
automatically scan your `:source-paths` for Java files. This will compile Java
classes once:

```clj
boot.user=> (boot (javac*))
```

Or you can enable automatic background recompilation like in lein-virgil:

```clj
boot.user=> (def f (future (boot (comp (watch) (javac*)))))
;; Then, to disable:
boot.user=> (future-cancel f)
```

In your build pipelines, you can continue to use the Boot's built-in `javac`
task.

`javac*` task supports the following parameters:

- `:verbose` — print every class name that is compiled.
- `:options` — a vector of strings that is passed to Java compiler, same as to
  `javac` binary. E.g., you can use `(javac* :options ["-Xlint:unchecked"])` to
  print additional warnings from the compiler.

### license

Copyright © 2016 Zachary Tellman

Distributed under the MIT License

repository: clojure-land/virgil

repo_name: clojure-land/virgil


text:
# Rho language Tests
Rho is much like _Python_, but with an even less verbose syntax.

The 'return value' for a Rho function is whatever is left on the stack(s).

_Rho_ is internally translated to _Pi_ for use in a single _Executor_ that supports continuations natively.

Example:

```
fun a(b, c)
	b + c

assert a(1, 2) == 3

fun d(e)
	fun f(g)
		g*2
	f(e)

assert d(2) == 4
assert exists a
assert exists d
assert !(exists f)

fun h(i,j,k)
	a(i, d(j)*k)

assert h(1,2,3) == 16
```

repository: cschladetsch/KAI

repo_name: cschladetsch/KAI


text:
## rework-palette [![Build Status](https://travis-ci.org/fgnass/rework-palette.png)](https://travis-ci.org/fgnass/rework-palette)

[Rework](https://github.com/visionmedia/rework) plugin to resolve custom CSS
color names. By default it uses the beautiful [clrs.cc](http://clrs.cc) palette.

### Example

```css
.foo {
  color: navy;
  border: 1px solid blue;
}
```

Yields:

```css
.foo {
  color: #0074d9;
  border: 1px solid #001f3f;
}
```

### Usage

```js
  var rework = require('rework');
  var palette = require('rework-palette');

  // Use the default palette
  rework(css).use(palette())

  // Use a custom palette
  rework(css).use(palette({
    red: '#EE0000',
    green: '#00EE00'
  }));
```

### The MIT License (MIT)

Copyright (c) 2014 Felix Gnass

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: fgnass/rework-palette

repo_name: fgnass/rework-palette


text:
---
layout: base
title:  'Statistics of Polite in UD_Indonesian-PUD'
udver: '2'
---

## Treebank Statistics: UD_Indonesian-PUD: Features: `Polite`

This feature is universal.
It occurs with 2 different values: `Form`, `Infm`.

71 tokens (0%) have a non-empty value of `Polite`.
6 types (0%) occur at least once with a non-empty value of `Polite`.
5 lemmas (0%) occur at least once with a non-empty value of `Polite`.
The feature is used with 1 part-of-speech tags: <tt>PRON</tt> (71; 0% instances).

### `PRON`

71 <tt>PRON</tt> tokens (5% of all `PRON` tokens) have a non-empty value of `Polite`.

The most frequent other feature values with which `PRON` and `Polite` co-occurred: <tt>PronType</tt><tt>=Prs</tt> (71; 100%), <tt>Number</tt><tt>=Sing</tt> (70; 99%), <tt>Person</tt><tt>=1</tt> (55; 77%).

`PRON` tokens may have the following values of `Polite`:

* `Form` (66; 93% of non-empty `Polite`): saya, Anda
* `Infm` (5; 7% of non-empty `Polite`): Aku, kalian, kamu
* `EMPTY` (1258): yang, nya, ia, mereka, itu, ini, kami, dia, mana, kita

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

gha_language: HTML

repo_name: UniversalDependencies/docs


text:
+++
date = "2009-07-30T20:51:12-07:00"
title = "Lasting linguistics: Making a meaningful mark"
#time_start = 2009-07-30T13:00:00
#time_end = 2009-07-30T15:00:00
abstract = ""
abstract_short = "This was three mini-presentations on language documentation."
event = "University of North Dakota linguistics colloquium series"
event_url = ""
location = "University of North Dakota, Grand Forks, North Dakota"

# Is this a selected talk? (true/false)
selected = false

# Projects (optional).
#   Associate this talk with one or more of your projects.
#   Simply enter the filename (excluding '.md') of your project file in `content/project/`.
# projects = ["deep-learning"]

# Links (optional).
url_pdf = ""
url_slides = "Other-Content/colloquium/Making-it-last-Paterson/Making-it-last-Paterson-Slides.pdf"
url_video = ""
url_code = ""
url_dataset = ""

# Tags (optional).
#   Set `tags = []` for no tags, or use the form `tags = ["A Tag", "Another Tag"]` for one or more tags.
tags = ["Preservation Studies"]

#[[url_custom]]
# name = "Blog Post"
# url = "http://hugh.thejourneyler.org/2009/lasting-linguistics-making-a-meaningful-mark/"
# Does the content use math formatting
    math = false
# Does the content use source code highlighting?
    highlight = true

  [header]
    caption = "Image from War Robots Fandom Wiki. Licensed CC-BY-SA"
    image = "headers/archive-wide.jpg"
+++

**Citable as**

Hugh J. Paterson III, John Clifton & Steve A. Marlett (2009) Lasting Linguistics: Making a Meaningful Mark. University of North Dakota 2009 linguistics colloquium series, 30 July.

**Summary**

This was three mini-presentations covering different perspectives on language documentation. Materials from the presentation include two slide decks and two handouts. My main presentation point is that we should be considering Search dynamics and Search Engine Optimization for language documentation materials.


text:
# MOC Uteis
MOC Uteis is a library for php for agility developement and simplify the proccess.

## Install
`composer require moc-solucoes/moc-uteis`

### Examples
You can find practical usage examples in [examples](https://github.com/maikees/moc-uteis/tree/master/examples) path.

## License
This library is released under the [MIT license](https://github.com/maikees/moc-uteis/blob/master/LICENSE).

## Maintained by
This library is maintained by [MOC SOLUÇÕES](http://mocsolucoes.com.br).

repository: maikees/moc-uteis

repo_name: maikees/moc-uteis


text:
# mold-source-map [![build status](https://secure.travis-ci.org/thlorenz/mold-source-map.png)](http://travis-ci.org/thlorenz/mold-source-map)

Mold a source map that is almost perfect for you into one that is.

```js
browserify()
  .require(require.resolve('./project/js/main.js'), { entry: true })
  .bundle({ debug: true })

  // will show all source files relative to jsRoot inside devtools
  .pipe(mold.transformSourcesRelativeTo(jsRoot))
  .pipe(fs.createWriteStream(bundlePath));
```
Full example [here](https://github.com/thlorenz/mold-source-map/blob/master/examples/browserify-sources.js).

## Installation

    npm install mold-source-map

## API

### Transforms

Transforms return a duplex stream and are therefore easily threaded into a bundler that streams the generated bundle,
like [browserify](https://github.com/substack/node-browserify).

#### transform(function map(sourcemap[, callback]) {})

This is the most generic and powerfull feature as it allows replacing the entire sourcemap comment with another `String`.

It takes a map function as input whose `sourcemap` argument has all information and lots of functions regarding the existing source map.

The optional `callback` can be used to call back with the final source map comment. If it is given, the transform will
invoke the function asynchronously, otherwise you may just return the final source map comment.

Here is a snippet from [an example](https://github.com/thlorenz/mold-source-map/blob/master/examples/browserify-external-map-file.js)
showing how to use this in order to write out an external map file and point the browser to it:

```js
function mapFileUrlComment(sourcemap, cb) {

  // make source files appear under the following paths:
  // /js
  //    foo.js
  //    main.js
  // /js/wunder
  //    bar.js

  sourcemap.sourceRoot('file://');
  sourcemap.mapSources(mold.mapPathRelativeTo(jsRoot));

  // write map file and return a sourceMappingUrl that points to it
  fs.writeFile(mapFilePath, sourcemap.toJSON(2), 'utf-8', function (err) {
    if (err) return console.error(err);
    cb('//@ sourceMappingURL=' + path.basename(mapFilePath));
  });
}

browserify()
  .require(require.resolve('./project/js/main.js'), { entry: true })
  .bundle({ debug: true })
  .pipe(mold.transform(mapFileUrlComment))
  .pipe(fs.createWriteStream(bundlePath));
```

[This example](https://github.com/thlorenz/mold-source-map/blob/master/examples/browserify-external-map-file-sync.js) achieves the same using sync operations.

### Convenience Transforms

The below transforms addressing special use cases. These cases all could be implemented with the generic transform as well.

### transformSourcesRelativeTo(root : String)

```
/**
 * Adjusts all sources paths inside the source map contained in the content that is piped to it.
 *
 * Example: bundleStream.pipe(mold.sourcesRelative(root)).pipe(fs.createWriteStream(bundlePath))
 *
 * @name sourcesRelative
 * @function
 * @param root {String} The path to make sources relative to.
 * @return {Stream} A duplex stream that writes out content with source map that had all sources paths adjusted.
 */
 ```

## Unstable API

A more custom/advanced API will be/is exposed, however it is still in high fluctuation.

Take a look at the `index.js` to get an idea of what's coming/already there.

repository: thlorenz/mold-source-map

repo_name: thlorenz/mold-source-map


text:
# About the Project

-	Although we know that Hippocampus is involved in memory
storage, we are still unclear of how it does so.
-	The heterogeneity among neurons makes it difficult
to study how brain circuits are formed and to
resolve neuronal connections
-	Sample: Single cell sequencing reads of mouse
Hippocampus region from 10x platform
-	Language: R– packages Seurat, gdata, Matrix,
tidyverse, dplyr

![Project Brief 1](P1.png "Project Brief 1")

Dimension Reduction by UMAP and clustering of the scRNA-seq data generated 22 clusters of cells.

![Project Brief 2](P2.png "Project Brief 2")

On plotting marker genes, two broad classes of neurons were established.
Inhibitory neurons:
![Project Brief 3](P3.png "Project Brief 3")

Excitatory Neurons:
![Project Brief 4](P4.png "Project Brief 4")

Gene markers helped to identify clusters and sub-clusters of cells. Each gene marker marked a specific part of cluster.

![Project Brief 5](P5.png "Project Brief 5")

Finding type of cell for each cluster, we focused on each cluster individually to find subparts. For example, in the figure below, Adarb2 gene marks the mother cluster and Tnfaip8l3, Syt6, Vip, Penk mark specific regions in the mother cluster.
![Project Brief 6](P6.png "Project Brief 6")


text:
# HearthStone Card Data Import
The is a quick import of JSON data containing info on the cards using .NET, Entity Framework 6 and JSON.NET

For more information you can read my blog on this application:

[HearthStone, EntityFramework and JSON](https://ericwildblog.azurewebsites.net/hearthstone-entity-framework-and-json/)

repository: ewild/HearthStoneCardDataImport

repo_name: ewild/HearthStoneCardDataImport


text:
---
title: |
    778. Sabbath Eve - Christ in Song
metadata:
    description: |
        Christ in Song 778. Sabbath Eve. How sweet the light of Sabbath eve! How soft the sunbeams ling'ring there! For these blest hours the world I leave, Wafted on wings of faith and pray'r.
    keywords:  |
        Christ in Song, adventhymnals, advent hymnals, Sabbath Eve, How sweet the light of Sabbath eve!.
    author: Brian Onang'o
---

#### Advent Hymnals
## 778. SABBATH EVE
####  Christ in Song,

```txt
1.
How sweet the light of Sabbath eve!
How soft the sunbeams ling'ring there!
For these blest hours the world I leave,
Wafted on wings of faith and pray'r.

2.
Season of rest!  the tranquil soul
Feels the sweet calm, and melts in love;
And while these sacred moments roll,
Faith sees a smiling heav'n above.

3.
Nor will our days of toil be long;
Our pilgrimage will soon be trod;
And we shall join the ceaseless song,
The endless Sabbath of our God.

```

- |   -  |
-------------|------------|
Title | Sabbath Eve |
Key | D Major |
Titles | undefined |
First Line | How sweet the light of Sabbath eve! |
Author | J. Edmeston
Year | 1908
Composer| L. Mason |
Hymnal|  - |
Tune| MALVERN |
Metrical pattern | |
# Stanzas |  |
Chorus |  |
Chorus Type |  |
Subjects | Hymns for Worship: Evening Hymns |
Texts | undefined |
Print Texts |
Scripture Song |  |

repository: GospelSounders/adventhymnals

repo_name: GospelSounders/adventhymnals


text:
__gitup__ (the _git-repo-updater_)

[![ci](https://github.com/earwig/git-repo-updater/actions/workflows/ci.yml/badge.svg)](https://github.com/earwig/git-repo-updater/actions/workflows/ci.yml)

gitup is a tool for updating multiple git repositories at once.  It was originally created to manage a large
collection of projects and deal with sporadic internet access.

gitup should work on macOS, Linux, and Windows. You should have the latest
version of git and either Python 2.7 or Python 3 installed.

# Installation

With [pip](https://github.com/pypa/pip/):

    pip install gitup

With [Homebrew](http://brew.sh/):

    brew install gitup

## From source

First:

    git clone git://github.com/earwig/git-repo-updater.git
    cd git-repo-updater

Then, to install for everyone:

    sudo python setup.py install

or for just yourself (make sure you have `~/.local/bin` in your PATH):

    python setup.py install --user

Finally, simply delete the `git-repo-updater` directory, and you're done!

__Note:__ If you are using Windows, you may wish to add a macro so you can
invoke gitup in any directory. Note that `C:\python27\` refers to the
directory where Python is installed:

    DOSKEY gitup=c:\python27\python.exe c:\python27\Scripts\gitup $*

# Usage

There are two ways to update repos: you can pass them as command arguments,
or save them as "bookmarks".

For example:

    gitup ~/repos/foo ~/repos/bar ~/repos/baz

will automatically pull to the `foo`, `bar`, and `baz` git repositories.
Additionally, you can just type:

    gitup ~/repos

to automatically update all git repositories in that directory.

To add bookmarks, either of these will work:

    gitup --add ~/repos/foo ~/repos/bar ~/repos/baz
    gitup --add ~/repos

Then, to update all of your bookmarks, just run gitup without args:

    gitup

Delete a bookmark:

    gitup --delete ~/repos

View your current bookmarks:

    gitup --list

You can mix and match bookmarks and command arguments:

    gitup --add ~/repos/foo ~/repos/bar
    gitup ~/repos/baz            # update 'baz' only
    gitup                        # update 'foo' and 'bar' only
    gitup ~/repos/baz --update   # update all three!

Update all git repositories in your current directory:

    gitup .

You can control how deep gitup will look for repositories in a given directory,
if that directory is not a git repo by itself, with the `--depth` (or `-t`)
option. `--depth 0` will disable recursion entirely, meaning the provided paths
must be repos by themselves. `--depth 1` will descend one level (this is the
old behavior from pre-0.5 gitup). `--depth -1` will recurse indefinitely,
which is not recommended. The default is `--depth 3`.

By default, gitup will fetch all remotes in a repository. Pass `--current-only`
(or `-c`) to make it fetch only the remote tracked by the current branch.

Also by default, gitup will try to fast-forward all branches that have
upstreams configured. It will always skip branches where this is not possible
(e.g. dirty working directory or a merge/rebase is required). Pass
`--fetch-only` (or `-f`) to skip this step and only fetch remotes.

After fetching, gitup will _keep_ remote-tracking branches that no longer exist
upstream. Pass `--prune` (or `-p`) to delete them, or set `fetch.prune` or
`remote.<name>.prune` in your git config to do this by default.

For a full list of all command arguments and abbreviations:

    gitup --help

repository: earwig/git-repo-updater

branch_name: refs/heads/develop

gha_language: Python

repo_name: earwig/git-repo-updater


text:
---
title: Citizen Services
date: 2017-08-28 00:00:00 Z
layout: redirected
sitemap: false
redirect_to:  "https://louisvilleky.gov/government/civic-innovation-and-technology/citizen-services"
position: 3
image_path: "/assets/img/projects/citizen-services/digital-services.jpg"
permalink: "innovation/citizen-services/"
---

Follow this project

{: .center-image }

The future of the Smart City is constantly being redefined, and by extension our relationship with citizens. The advent of the Smart Home offers an opportunity to connect with our constituents in new and exciting ways that weren't previously possible. The following projects illustrate our strategy of testing different technologies to democratize open government data and put it in useful contextual applications for our citizens.

## American Printing House for the Blind, Indoor Navigation

![APH graphic](/assets/img/projects/citizen-services/aph.jpg)

We have partnered with the American Printing House for the Blind to install low power, bluetooth beacons in public buildings, and map these indoor spaces for accessibility and public usage, with all data generated contributed to OpenStreetMap. It is an exciting and innovative opportunity to improve public buildings for all in our community through their Indoor Explorer platform.

This technology was recently promoted and demonstrated to an audience from the NewDEAL organization (Developing Exceptional American Leaders), a national network of progressive state and local leaders.

![beacon graphic](/assets/img/projects/citizen-services/beacon.png){: .center-image }

In December 2017, the Louisville International Airport (SDF) became the first fully accessible airport to travelers who are blind or visually impaired and in January 2018, the Kentucky Center for the Arts became the first fully accessible performing arts venue to patrons who are blind or visually impaired.

## IFTTT Resident Notifications

Innovation has [built a connection to the free service IFTTT](https://ifttt.com/smartlouisville) (IF This, Then That) that lets residents get notifications from the city the way they want them.  Things like emergency alerts, air quality, city jobs, city news, and Metro Council meeting agendas, minutes, videos, and bills can be sent to residents via text message, email, Twitter, Facebook Messenger, Hue light bulbs, and other smart devices. These can be mixed and matched in countless ways, helping get the information you need in the manner you need, and is of particular value for visually or audibly impaired residents.  Louisville is the first government on the platform, which initiated IFTTT's creation of the government Data Access Project.

An open source project, our IFTTT code is freely available and licensed on GitHub. We have created a new channel for governments to deliver light touch digital services, that empower the citizen to customize their interaction with government while maintaining respect for their privacy. The IFTTT service has a tightly controlled user experience that allows us to present a consistent service to our citizens, in an era of poorly designed government app experiences. It allows us to democratize and operationalize data to our citizens, solving a historic issue with Open Data, providing immediate and applicable value to the initiative.

* [IFTTT announcement](https://medium.com/louisville-metro-opi2/mayor-fischer-announces-city-partnership-with-ifttt-76f7b1fe2ce0)
* [Web page with our Citizen Digital Services](https://projects.lsvll.io/projects/citizen-services/)
* [CNET Article](https://www.cnet.com/news/hows-the-air-up-there-in-louisville-you-can-just-ask-your-light-bulbs/)

![IFTTT graphic](/assets/img/projects/citizen-services/ifttt.webp)

Get your city started with IFTTT & [view the source code](https://github.com/LouisvilleMetro-Innovation) or get connected with [Smart Louisville](https://ifttt.com/smartlouisville)!

## Smart Assistant Skills (Alexa, Google Assistant)

![digital assistants](/assets/img/projects/citizen-services/assistants.png)

Our citizen's expectations are being set by the pace and responsiveness of private industry. The future of government is not behind paper forms, or labyrinth processes but instead the future of our government is ubiquitous service and availability. The citizen expectation is to be able to solve their problems quickly, efficiently and with as little energy as possible.

To accomplish this effort, the Office of Civic Innovation is experimenting with several Smart Assistants, and Voice User Interfaces (VUIs). By engaging with our local Code for America chapter, we have created a number of community developed skills, primarily for (but not limited to) the Amazon Alexa digital assistant. This allows us to experiment with voice interaction, a new channel for digital citizen services.

As these technologies have a greater impact and influence on our lives, and are developed for citizens by their local government, it is important the citizens have the capability and option to review the code of this software. You can review this project, and many others on our organization page on [GitHub](https://github.com/louisvillemetro-innovation).

As all citizens leverage and use technology platforms differently, we currently have a multi-platform digital assistant solution in development that will address the need for a platform agnostic solution.

[View available Alexa Skills on Amazon](https://www.amazon.com/s/ref=nb_sb_noss_2?url=search-alias%3Dalexa-skills&field-keywords=Louisville)

Learn More

{: .center-image }


text:
# CS50's Introduction to Computer Science - HarvardX, Fall 2020

**Course followed on** [edX](https://www.edx.org/course/cs50s-introduction-to-computer-science)

This reposiroty contains my notes and solutions to each problem proposed in class.

 ## [Week 0](https://cs50.harvard.edu/x/2020/weeks/0/)
 * Problem Set 0 → Scratch
    * [problem-set-0-final.sb3](./pset0/problem-set-0-final.sb3)

 ## [Week 1](https://cs50.harvard.edu/x/2020/weeks/1/)
 * Problem Set 1 → C
    * [Hello](./pset1/hello/)
    * [Mario less](./pset1/mario/less)
    * [Cash](./pset1/cash)

 ## [Week 2](https://cs50.harvard.edu/x/2020/weeks/2/)


text:
## Overview

This example shows how to execute a spark streaming example on the BigInsights cluster that consumes messages from IBM MessageHub (Kafka).  Note that the spark streaming job runs on a single node and not as a yarn application.

## See also

- See here for a similar project aimed at IBM Data Science Experience (DSX) - https://github.com/snowch/SparkMessageHubScala
- Please add your +1 to this [ticket](https://github.com/ibm-messaging/message-hub-samples/issues/11) to add similar examples to this example for pyspark and spark 2.x
- This example is similar to [SparkMessageHubScalaYarn](../SparkMessageHubScalaYarn) but in that version the spark streaming job runs as a yarn application. If you are just starting with Spark Streaming and MessageHub, it is recommended that you use this example as it is much easier to debug.

## Developer experience

Developers will gain the most from these examples if they are:

- Comfortable using Windows, OS X or *nix command prompts
- Familiar with Scala
- Familiar with the [Gradle](https://gradle.org/) build tool
- Familiar with Spark concepts such as spark streaming
- Familiar with MessageHub (Kafka)

## Example Requirements

- You meet the [pre-requisites](../../README.md#pre-requisites) in the top level [README](../../README.md)
- You have performed the [setup instructions](../../README.md#setup-instructions) in the top level [README](../../README.md)
- You are using BigInsights 4.2 with Spark 1.6 (this solution has not been tested with BigInsights 4.3 and Spark 2.0)
- You have setup an instance of MessageHub
- If you want to use the python script for sending messages to kafka, you must have:
  - Python 3.x installed
  - kafka-python library installed (`pip install kafka-python`)

## Run the example

To run the examples, in a command prompt window:

   - copy vcap.json_template to vcap.json
   - edit vcap.json with your messagehub connection details
   - change into the directory containing this example and run gradle to execute the example
      - `./gradlew Example` (OS X / *nix)
      - `gradlew.bat Example` (Windows)
   - While the streaming example is running, open a new terminal window and execute the python script, e.g.
      - `python send_message.py 12345`
   - Ssh into your cluster
   - Run `hdfs dfs -ls /user/<<your_username>>/` to see the output folders
   - Run `hdfs dfs -cat /user/<<your_username>>/test-<<output_folder_uuid>>/*`

You should see something like this:

```
-bash-4.1$ hdfs dfs -cat /user/snowch/test-0458b164-007e-465a-89fe-13aa8f40f35d/*
(null,12345)
```

When you have finished running, CTRL-C the window running `./gradlew Example`, then run `./gradlew KillAll` to kill the streaming example on the cluster.

## Decomposition Instructions

The [./build.gradle](./build.gradle) script runs the example.  Build.gradle:

- compiles [MessageHubConsumer.scala](./src/main/scala/biginsights/examples/MessageHubConsumer.scala)
- compiles helper classes in the package [com.ibm.cds.spark.samples.*](src/main/scala/com/ibm/cds/spark/samples/)
- package MessageHubConsumer classes and dependencies into a jar file `build/libs/SparkMessageHubScala-all.jar`

It then uses a ssh plugin to:

- copy `build/libs/SparkMessageHubScala-all.jar` to the BigInsights cluster
- from the ssh session, execute the MessageHubConsumer spark streaming job

It is recommended that you spend time investigating the classes in the package `com.ibm.cds.spark.samples.*`.  You will probably need to make changes in these classes, especially in the method `initConfigKeys()` in [MessageHubConfig](src/main/scala/com/ibm/cds/spark/samples/config/MessageHubConfig.scala)


text:
# Client
[![Build Status](https://travis-ci.org/bonzofenix/client.png)](https://travis-ci.org/bonzofenix/client)

Client provides you with metaprogram ruby rest clients generated from yml configurations.

## Installation

Add this line to your application's Gemfile:

    gem 'client'

and run `bundle`

## Usage
Client tries to generate rest clients as soon as you require the gem.
It will try to find `client.yml` in the main folder of your project:

    /my_project/client.yml

The yaml should look something like this:

```yml
    google:
        base_uri: 'http://www.google.com'
    twitter:
        base_uri: 'http://www.twitter.com'
```

This will generate a rest client for you to perform post and gets and return NET/HTTP responses:

```ruby
    require 'client'
    Client::Google.get 'search', query: {q: 'bonzofenix gem client'}
    #This should perform a GET to http://www.google.com/search?q=bonzofenix+gem+client

    #Some rest magic too:

    Client::Twitter.list_tweets(query: {user_id: 2}) #also try find_
    #This should perform a GET to http://www.twitter.com/tweets?user_id=2

    Client::Twitter.list_tweets(1, query: {token: 'asd123'}) #also try find_1
    #This should perform a GET to http://www.twitter.com/tweets/1?token=asd123

    Client::Twitter.destroy_tweets(3) #also try remove_ delete_
    #This should perform a DELETE to http://www.twitter.com/tweets/3

    Client::Twitter.create_tweet(body:{text: 'a tweet'}) #also try post_
    #This should perform a POST to http://www.twitter.com/tweets with body: text='a tweet'

    Client::Twitter.create_tweet(body: {text: 'a tweet'}, content_type: :json) #also try post_
    #This should perform a POST to http://www.twitter.com/tweets with body: '{"text": "a tweet"}' and header CONTENT-TYPE application/json
```

You can also load specific yml files:

```ruby
    require 'client'
    Client.load_clients 'config/twitter.yml', 'config/google.yml'
    Client::Twitter
    # => Client::Twitter
    Client::Google
    # => Client::Google
```

See the spec folder for more examples.

## Contributing

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

repository: bonzofenix/client

repo_name: bonzofenix/client


text:
# Pacman-With-Voice-Commands
![Game Template Image](Pacman%20With%20Voice%20Commands/images/game-template.png)

## Requirement

- Get your own [Alan AI SDK key](https://alan.app/) for voice commands

## How to open the file and play
Download code as a zip file.
Open the file with VSCode
Paste your **Alan AI SDK Key** on line **420** under **app.js** file.
![Where to paste you Alan SDK Key](Pacman%20With%20Voice%20Commands//images/alan-key.png)

- There are two ways:
1. Double click **index.html** and click *Copy Path*. Then paste the paste in your favorite browser.
2. Double click **index.html** and click *Open In Default Browser*.

## Resources
- [Alan AI](https://alan.app/)
- [JavaScript on W3School](https://www.w3schools.com/js/)
- [CSS on W3School](https://www.w3schools.com/css/)
- [HTML on W3School](https://www.w3schools.com/html/)
- [HTML5 Pacman CodePen](https://codepen.io/hellokatili/pen/xwKRmo)
- [Mozilla CSS related docs](https://developer.mozilla.org/en-US/)
- [Build PACMAN in vanilla JavaScript, HTML and CSS](https://www.youtube.com/watch?v=CeUGlSl2i4Q&list=RDCMUC5DNytAJ6_FISueUfzZCVsw&index=8)
- [Build Pacman in pure JavaScript with voice commands](https://www.youtube.com/watch?v=kBVaH3D92H8)

## MIT Licence
Copyright (c) 2021 Aiko Zhao

repository: aikozhaoz/Pacman-With-Voice-Commands

repo_name: aikozhaoz/Pacman-With-Voice-Commands


text:
# json-scanner
This **BSD licensed**, **C library** tokenizes a **JSON** byte buffer. **No copying** is done as JsonTokens contain pointers to the underlying buffer, as well as the type of token. Drop straight into project. **C99**.

### Example
    const uint8_t *data = "[ 1, true, 3 ]";
    size_t data_len = strlen(data);
    JsonScanner sc;
    for (JsonToken t = json_scanner_init(&sc, data, data_len);
         t.type != JST_EOF && !json_scanner_error(t);
         t = json_scanner_next(&sc, t)) {

        fwrite(t.start, sizeof(uint8_t), t.len, stdout);
    }
    // no free necessary

repository: sigurdteigen/json-scanner

gha_language: C

gha_license_id: NOASSERTION

repo_name: sigurdteigen/json-scanner


text:
# List View Tutorial

This tutorial is the first of a series of tutorials that explains how to extend the Leitstand UI.
This tutorial discusses how to add a list view. The next tutorials explain how to add new entity to resource collection, edit and existing resource and remove a resource.

The tutorial is based on the Leitstand webhook management UI and explains the implementation of the webhook list shown below:

![Webhook list view](assets/webhooks.png "Webhooks list view")

All code listings are taken from the Leitstand UI.

Recalling the model view controller pattern, the UI is formed by
- a client to load the resource and translate it to the view model
- a view template
- a controller to render the view and handle all events.

## Webhooks Resource
The first step is to implement a client to access the webhooks resource through the REST API.
The webhooks resource endpoint is `/api/v1/webhooks` and accepts an optional `filter` parameter to query webhooks by their name.

```ES6
import {Resource} from '/ui/js/client.js';

/**
 * Webhook collection
 */
export class Webhooks extends Resource {

  /**
   * Loads all configured webhooks
   * @returns {Promise} a promise to process the webhook collection or an error response
   * @see WebhookReference
   */
  load(params) {
    return this.json('/api/v1/webhooks?filter={{filter}}',
				    params)
               .GET();
  }

  /**
   * Adds a new webhook.
   * @param {WebhookSettings} settings the webhook settings
   */
  addHook(settings){
    return this.json("/api/v1/webhooks/")
               .POST(settings);
  }

}

```

The REST API returns a list of webhook references. Each reference contains
- the webhook ID
- the webhook name
- an optional webhook description
- a flag indicating whether the webhook is enabled
- the subscribed topic and the event selector

```JSON
[{"webhook_id":"03bd6e00-1042-4422-bb15-283a6825db07",
  "webhook_name":"DNS",
  "description":"Forward DNS records to PowerDNS",
  "topic":"element",
  "selector":"DnsRecord.*",
  "enabled":true},
 {"webhook_id":"8c697515-e0a9-460d-95c3-afc99c406341",
  "webhook_name":"ZTP",
  "description":"Create ZTP configuration for cloned elements.",
  "topic":"element",
  "selector":"ElementClonedEvent",
  "enabled":true}]
```

## View Template
The view template translates the webhook references into a table or displays a blankslate if no webhooks exists.

Leitstand UI templates are Mustache templates and use the Leitstand component library.
Mustache is a logic-less template engine, which means that mustache only allows to iterate through the object model.
A template section is omitted, if a property is `undefined`, `null`, `false`, or `0`.

```HTML
<ui-view-header>
  <ui-title>Webhooks</ui-title>
  <ui-subtitle>Listing of all existing webhooks</ui-subtitle>
</ui-view-header>
<ui-form scopesAllowed="adm adm.webhook">
  <ui-filter name="filter">
    <ui-label>Filter</ui-label>
    <ui-note>Filter webhooks by their name</ui-note>
  </ui-filter>
  <!--  {{#hooks.length}} -->
  <ui-group>
    <ui-label>Webhooks</ui-label>
    <table class="list">
      <thead>
        <tr>
          <th>Name</th>
          <th>State</th>
          <th>Topic</th>
          <th class="text">Message Selector</th>
          <th class="text">Description</th>
        </tr>
      </thead>
      <tbody>
        <!-- {{#hooks}} -->
        <tr>
          <td><a href="webhook.html?hook={{hook_id}}" title="View hook settings">{{hook_name}}</a></td>
          <td><span class="{{state}}">{{state}}</span></td>
          <td>{{topic_name}}</td>
          <td class="text">{{selector}}</td>
          <td class="text">{{description}}</td>
        </tr>
        <!--  {{/hooks}}-->
      </tbody>
    </table>
  </ui-group>
  <!--  {{/hooks.length}} -->
  <!--  {{^hooks}} -->
  <ui-blankslate>
    <ui-title>No webhooks found</ui-title>
    <ui-subtitle>Please amend the filter expression or add a missing webhook.</ui-subtitle>
  </ui-blankslate>
  <!--  {{/hooks}} -->
  <ui-actions>
    <ui-button href="new-webhook.html" primary scopesAllowed="adm adm.webhook">Add webhook</ui-button>
  </ui-actions>
</ui-form>
```
First the view header, including view title and subtitle, is declared, followed
by a filter (`<ui-filter...>` component) for filtering the displayed the webhook list items.
Next, the template declares a table to list all webhooks and creates a table row per hook (`{{#hooks}}...{{/hooks.length}}`), if the `hooks` array in the view model is not empty (`{{#hooks.lenth}}..{{/hooks.length}}`)
The `#` walks down the object hierarchy and creates a new context to read the properties from.
If the specified property is an array, the section is executed for each array item.
The template renders a blankslate if the `hooks` array is empty or does no exist.

![No webhooks found](assets/webhooks_blankslate.png "No webhooks found.")

The Mustache instructions are put into HTML comments to preserve a valid HTML syntax.

## Controller
The controller accesses the `Webhooks` resource, translates the resource into a view model and renders the view.
The view model consists of three properties:
- the `hooks` array contains all existing webhooks
- the `state` function translate the `enabled` flag to a human-friendly name
- the `filer` string contains the currently applied filter.
Moreover, the controller implements the filter function, that applies the current filter to the list view by means of reloading the view with the new filter expression.

```ES6
import {Controller,Menu} from '/ui/js/ui.js';

let webhooksController = function() {
  let hooks = new Webhooks();
  return new Controller({
    resource:hooks,
    viewModel:function(hooks){
      return {'hooks':hooks,
              'state':function(){
                return this.enabled ? 'UP' : 'DOWN';
              },
              'filter':this.location().param('filter')};
    },
    buttons:{
      'filter':function(){
        this.reload({'filter':this.input('filter').value()});
      }
    }
  });
};
```
The final step is to register the controller in the module menu.
The webhooks view is a master-detail view.
The master page lists all existing webhooks.
The detail page allows to add new webhooks.

```ES6
let webhooksView = {
  'master':webhooksController(),
  'details':{'new-webhook.html':newWebhookController()}
};

```

Therefore, the `webhooks.html` template is bound to the webhooks view declaration.

```ES6

export const menu = new Menu({'webhooks.html':webhooksView});
```

The next tutorial discusses how to [add a new webhook](./add_tutorial.md).


text:
---
id: installation
title: Installation
sidebar_label: Installation
---

*This page assumes you are comfortable with [Git](https://en.wikipedia.org/wiki/Git), [Command Line](https://en.wikipedia.org/wiki/Command-line_interface), [Python](https://en.wikipedia.org/wiki/Python_(programming_language)), [Docker](https://en.wikipedia.org/wiki/Docker_(software)), and [NPM](https://en.wikipedia.org/wiki/Npm_(software)). You must have all of these installed on your machine.*

### WordWeaver

1. First, clone the WordWeaver repository: ```git clone https://github.com/nrc-cnrc/wordweaver```
2. To install WordWeaver: `cd wordweaver && docker-compose build`

### WordWeaver-UI

1. Second, clone the WordWeaver-UI repository: ```git clone https://github.com/nrc-cnrc/wordweaver-UI```
2. To install WordWeaver-UI: `cd wordweaver-UI && npm install`

You're now ready to go on to your [first steps](ww-firststeps.md)!

repository: dlothian/wordweaver-docs

repo_name: dlothian/wordweaver-docs


text:
# Bean Juice
[![AppStore download image](https://tools.applemediaservices.com/api/badges/download-on-the-app-store/black/en-US?size=250x83&releaseDate=1587340800&h=f0754b335d9a14d7a7035ccad2e06d7e)](https://apps.apple.com/us/app/bean-juice/id1502380351?itsct=apps_box&itscg=30200)

[![issues](https://img.shields.io/github/issues/NiftyTreeStudios/Bean-Juice?style=flat-square)](https://github.com/NiftyTreeStudios/Bean-Juice/issues)
[![forks](https://img.shields.io/github/forks/NiftyTreeStudios/Bean-Juice?style=social&logo=github)](https://github.com/NiftyTreeStudios/Bean-Juice/network/members)
[![stars](https://img.shields.io/github/stars/NiftyTreeStudios/Bean-Juice?style=social&logo=github)](https://github.com/NiftyTreeStudios/Bean-Juice/stargazers)
[![license](https://img.shields.io/github/license/NiftyTreeStudios/Bean-Juice?style=flat-square)](https://github.com/NiftyTreeStudios/Bean-Juice/blob/master/LICENSE)
[![twitter](https://img.shields.io/twitter/url?url=https%3A%2F%2Fgithub.com%2FNiftyTreeStudios%2FBean-Juice)](https://twitter.com/BeanJuiceApp)

A simple app for coffee brewing recipes

![screenshot](bean-juice-ss.jpg "Screeshot")

Bean Juice is a simple coffee recipe app for iOS. It is written using SwiftUI (Some of the code needs to be refactored into SwiftUI 2.0).

repository: NiftyTreeStudios/Bean-Juice

gha_language: Swift

repo_name: NiftyTreeStudios/Bean-Juice


text:
---
layout: post
title: "Enhanced Ferromagnetic Stability in Cu Doped Passivated GaN Nanowires"
date: 2008-07-06 17:24:17
categories: arXiv_CV
tags: arXiv_CV GAN Face
author: H. J. Xiang, Su-Huai Wei
mathjax: true
---

* content
{:toc}

##### Abstract
Density functional calculations are performed to investigate the room temperature ferromagnetism in GaN:Cu nanowires (NWs). Our results indicate that two Cu dopants are most stable when they are near each other. Compared to bulk GaN:Cu, we find that magnetization and ferromagnetism in Cu doped NWs is strongly enhanced because the band width of the Cu td band is reduced due to the 1D nature of the NW. The surface passivation is shown to be crucial to sustain the ferromagnetism in GaN:Cu NWs. These findings are in good agreement with experimental observations and indicate that ferromagnetism in this type of systems can be tuned by controlling the size or shape of the host materials.

##### Abstract (translated by Google)

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

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


text:
This is a collection of my qbasic programs written in the 90's and early 00's. Each program originated from a concept that I wanted to learn and explore.

For this 2011 release:
 - Performed minor cleanup such as removing outdated contact info.
 - Tested with QB 4.5 (with /l qb.qlb) in DOSBox.
 - QB64 does not properly run many programs due to low level access and unsupported functions

3dtest.bas
 - original modified date: 2/9/2001 4:33 PM
 - Not really sure what this is supposed to be but was inspired by an Abrash book.
 - Does not work in qb 4.5 but I'm pretty sure it worked in qbasic.exe

3dcam.bas
 - original modified date: 12/29/2000 8:17 PM
 - appears to be a failed attempt at a 3d camera

cron.bas
 - original modified date: 5/11/2001 10:58 PM
 - Functional Tron lightcycle clone for multiple players. Also supports single player with poor AI.

farbfeld.bas
- original year: 2016
- sample images (.ff) are from <https://github.com/mehlon/farbfeld>

linklist.bas
- original modified date: 12/10/2000 9:16 PM
- Demonstrates an array-based linked list in the form of a scrolling stars.
- Uses screen 13 with wait retrace but flickers in doxbox for some reason.

matrix.bas
- original modified date: 12/9/2000 10:01 PM
- Inspired by the move The Matrix. Runs fairly slow in DOSBox.

md2view.bas
 - original modified date: 3/8/2001 9:35 PM
 - displays quake 2 model files in wireframe
 - models shamelessly taken from polycount

memcpy.bas
 - original modified date: 12/12/1997 8:29 AM
 - mem copy function

pcxread.bas
- original modified date: 2/15/1998 3:01 PM
- Reads an 8-bit pcx file for display very slowly

pcxre11a.bas
- original modified date: 3/6/1998 10:14 PM
- This should be the definitive version of pcxread.bas as it is much faster but has a fatal bug that
  renders the image distorted. Some day I may debug it.

poly3d.bas
- original modified date: 12/12/1997 8:29 AM
- Rotating cube with filled sides and backface removal. Way too many comments in that file.

polycoli.bas
- original modified date: 8/22/2000 1:40 PM
- demonstrates how to determine if a point is inside of a triangle using cross product

randmaze.bas
- original modified date: 12/15/2000 6:15 PM
- generates a maze. solves it.

raytest.bas
- original modified date: 5/16/1997 9:38 PM
- Failed attempt at a raycaster. Press tab to see the horror.

roots.bas
- original modified date: 6/5/2001 4:34 PM
- Draws somewhat crooked trees using recursion

shuffle.bas
- original modified date: 4/15/1999 12:29 AM
- shuffles cards

strscrnw.bas
- original modified date: 11/15/1996 10:14 PM
- Scrolling star demo with 3 layers

tpallete.bas
- original modified date: 6/15/1998 5:01 PM
- Sets a pallete and draws shades on the screen. Original was missing a NEXT statement.

tsprmsk.bat
- original modified date: 1/27/1998 3:59 PM
- Draws animated sprites using a bit mask for transparency. Runs slow in DOSBox.

vblock.bas
- original modified date: 7/14/1996 4:06 PM
- A "game" with a triangle that shoots at a block. Not sure why I didn't use vsync to avoid flicker.

vchess.bas
- original modified date: 6/5/1996 4:34 PM
- Challenging chess game in QB? Nope, just draws a board.

vpong.bas
- original modified date: 10/28/1996 7:56 PM
- Simple pong game with no ball physics.

vretrace.bas
- original modified date: 9/9/1997 5:16 PM
- A more verbose way of waiting for vsync.

wadread.bas
- original modified date: 3/29/1998 6:23 PM
- Reads data from doom WAD files and not much else.

walkth.bas
- original modified date: 6/10/1997 12:29 PM
- Overhead map thingy with collision detection

zshipmap.bas
- original modified date: 3/31/1997 2:45 PM
- Simple space ship physics with the ship centered in the screen. A planet is drawn for orientation.

zeroship.bas
- original modified date: 1/1/1997 3:10 PM
- Early version of zshipmap.bas with a stationary board.

License info:

Code is released under the MIT Open Source License. See mit-license.txt for details.
The md2 files in data/models are not my creation but from contributers to polycount.


text:
### Broad Goals
* [Paper on characterization of omega-methods]
* [Paper on omega-methods in large application problems]
* [Anisotropy metrics paper]

***

**Useful links:**
* Caskmodels repo: https://github.com/munkm/caskmodels
* Private caskmodels repo: https://github.com/munkm/caskmodels_private
* Advantg w/ omega methods:
* Exnihilo w/ omega methods:

***

### Miscellaneous Tasks
**Rachel**
* Ask Bob and Tom about running on Remus
* Backup running locations other than Remus?
  * Kelly probably has the knowledge to build everything on Savio now
  * Savio might not have the memory available to us that Remus does
* Determine where data for the runs will be uploaded (abacus?)

**Madicken**
* Document analysis scripts so they're usable for Vanessa and Emily
  * Most likely done in Jupyter notebooks
* Put link to custom advantg and exnihilo repos here, so cloning is
  straightforward
* Upload the exact configurations of the test problems into a branch of
  caskmodels
* Outline the characterization paper in repo.
 * My paper repo?
* QUESTION: Access to private caskmodels repo?

**Vanessa & Emily**
* GitHub tutorials on cloning, forking, pull requests
* clone my analysis script repo
* clone caskmodels repo
* try to make a parametric study of one of the example problems in
  `caskmodels/characterization_tests` that includes several quadrature orders

### Omega methods characterization paper

**Repo Link**: https://github.com/munkm/Papers/tree/master/methods_char

Items:
* To which journal do we want to submit?

### Omega methods in application problems paper

**Repo Link**:

Items:
* To which journal do we want to submit?

### Anisotropy metrics paper

**Repo Link**:

Items:
* To which journal do we want to submit?

repository: rachelslaybaugh/hybriddocs

repo_name: rachelslaybaugh/hybriddocs