text:
References:

[faye-websockets-part-1](https://www.driftingruby.com/episodes/faye-websockets-part-1)

[faye-websockets-part-2](https://www.driftingruby.com/episodes/faye-websockets-part-2)

[How to Use Faye as a Real-Time Push Server in Rails](http://code.tutsplus.com/tutorials/how-to-use-faye-as-a-real-time-push-server-in-rails--net-22600)

## Step1. Install Ruby environment in Ubuntu

Reference: [https://gorails.com/deploy/ubuntu/14.04](https://gorails.com/deploy/ubuntu/14.04)

### Add user
```
sudo adduser deploy
sudo adduser deploy sudo
su deploy
```
### Make sure you can login using new user

```
cd ~
mkdir .ssh
cd .ssh
vim authorized_keys
```
then put the content in `~/.ssh/id_rsa.pub` in your *local machine* into it.

### Install Ruby and RVM

```
sudo apt-get update

sudo apt-get install git-core curl zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev python-software-properties libffi-dev

sudo apt-get install libgdbm-dev libncurses5-dev automake libtool bison libffi-dev

gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3

curl -L https://get.rvm.io | bash -s stable

source ~/.rvm/scripts/rvm

rvm install 2.2.3

gem install bundler
```

### Create fake SSL for thin server

```
mkdir -p /home/deploy/faye-server/shared/thin/ssl
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /home/deploy/faye-server/shared/thin/ssl/thin.key -out /home/deploy/faye-server/shared/thin/ssl/thin.crt
```

### Create .env file
`vim /home/deploy/faye-server/shared/.env`

put like this

```
AUTH_TOKEN: 'your_secret'
```

### Create thin.yml file
ps. copied from `config/thin.yml.example`

`vim /home/deploy/faye-server/shared/config/thin.yml`

```
port: 8080
user: deploy
group: deploy
pid: /home/deploy/faye-server/current/faye/pids/thin.pid
timeout: 30
wait: 30
log: /home/deploy/faye-server/current/log/thin.log
max_conns: 4096
require: []
environment: production
max_persistent_conns: 1024
servers: 1
threaded: true
no-epoll: true
daemonize: true
chdir: /home/deploy/faye-server/current
tag: faye
ssl: true
ssl-key-file: /home/deploy/faye-server/current/thin/ssl/thin.key
ssl-cert-file: /home/deploy/faye-server/current/thin/ssl/thin.crt
ssl-disable-verify: true

```

## Step2.  Deployment

```
cap staging deploy
```

## How to test?

Before start you have to update the *IP* in `faye-server/test/index.html` and `faye-server/test/test.rb`

Then

```
cd faye-server/test
python -m SimpleHTTPServer 8000
```

Now you can open browser and type `http://localhost:8000/`

Then, you can type

```
irb
require './test'
t = SimpleTest.new
t.tester(1, 10)
```

repository: alChaCC/faye-server

gha_language: Ruby

repo_name: alChaCC/faye-server


text:
# vagrant-confluent-platform
Vagrantfile to start a virtual machine running the confluent platform: zookeeper, kafka, schema registry and confluent control center.

To use simply clone the repository and run:

```
vagrant up
```

The machine exposes the following ports:

- 2181: Zookeeper
- 8081: Schema registry
- 9021: Confluent Control Center
- 9092: Kafka

repository: htimur/vagrant-confluent

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: htimur/vagrant-confluent


text:
Cocoa library for creating signed requests according to the OAuth 1.0a standard.

Usage is fully documented in the header.

You will need to make your Xcode project link against CommonCrypto. Otherwise
just drag and drop. Or better yet, use git submodules:

    git submodule add https://github.com/guicocoa/cocoa-oauth.git

Tested against

- Twitter
- Foursquare
- Dropbox

Forked from [TDOAuth](https://github.com/tweetdeck/tdoauth)

repository: forcedotcom/RestKit

gha_language: Objective-C

repo_name: forcedotcom/RestKit


text:
# Commodity APIs
The Commodity APIs contains logic to APIs that can be re-used easily by a lot of organizations.

## Development
We use Vagrant to create the virtual environment of our development environment.  To load the dev environment using Vagrant, execute this code:

```bash

//create the VM:
vagrant up;

//ssh in the VM:
vagrant ssh;

//go at the root of our project:
cd /vagrant;

```

## Compile
To compile a recipe into PHP code, simply execute this command:

```bash

php vendor/bin/irestful compile http://<IP_ADDRESS>:8080 ./src/iRESTful/CommodityAPIs/Accounts/CRUD/recipe.json ./bin;

```

## Running the Docker image:
To run the docker image, we use docker-compose.  Execute the docker-compose recipe using this command:

```bash

//go in the generated code directory:
cd /vagrant/bin;

//install and start the application:
php start.php;

//stop the application:
php stop.php;

```

## Run the unit tests:
To run the unit tests, execute this command:

```bash

//go at the root of our project:
cd /vagrant;

//execute the unit tests:
php vendor/bin/phpunit --testsuite=unit;

```

## Watching applications
If you are working on the application and want to auto-compile while you work, simply execute this command.  It will auto-compile every time you save.

```bash

php vendor/bin/irestful watch http://<IP_ADDRESS>:8080 ./src ./bin;

```

## Building images
To build the docker images, simply run this command.

```bash

php vendor/bin/irestful build http://<IP_ADDRESS>:8080 ./src ./bin;

```

## Pushing docker images to the repository
To create a new version, simply execute this command.  It will render all the commands to run to push all the docker images to your docker repository.  You'll also need to login to your docker repository if not done already.

```bash

//login to your docker repository.  If you are already logged in, just skip this step:
docker login;

//run the push command:
php vendor/bin/irestful push ./src;

```

license: MIT

repository: xemmex/commodity-apis

repo_name: xemmex/commodity-apis


text:
---
layout: post
title: Meta-review on active learning strategies in digital learning environments
thumbnail: "/img/og_activelearning.png"
---

After a few years of conducting experiments in the MOOC environment and often finding that we were not able to replicate major insights from prior studies (conducted in the lab, classroom, a specifically designed online learning environment), we had an inkling that MOOC environments are tougher to crack. In order to turn this inkling into a scientific study we conducted a meta-review of so-called active learning strategies (strategies that involve learners in the learning process, e.g. gammification, cooperative learning) in the MOOC and other online learning environments. This study ([preprint](https://chauff.github.io/documents/publications/CE2018-Davis.pdf)), led by [Dan Davis](https://dan7davis.github.io/), was just published in the [Computers and Education](https://www.sciencedirect.com/journal/computers-and-education)
journal:

```bibtex
@article{CE2018ActiveLearning,
  author = {Dan Davis, Guanliang Chen, Claudia Hauff and Geert-Jan Houben},
  title = {Activating learning at scale: A review of innovations in online learning strategies},
  journal = {Computers \& Education},
  volume = {...},
  number = {...},
  pages = {...},
  year = {2018}
}
```

As a starting point to our meta-review we took [John Hattie's seminal work from 2008](https://www.taylorfrancis.com/books/9781134024124): _Visible learning: A synthesis of over 800 meta-analyses
relating to achievement_ on learning strategies used to facilitate active learning.
We considered **research published between 2009 and July 2017** that present empirical evaluations of these learning strategies.

We identified 7,706 papers in a first literature search round and used three criteria to determine whether a paper should be
in or out of our meta-review:

1. The learning  strategy  being  analyzed  must  have  been **scalable** (it does not require manual grading, feedback,
physical presence, etc.).
2. The evidence must come from empirical analyses of **randomized controlled experiments** with a combined
sample size of **at least ten** across all conditions.
3. The subjects of the studies must be **adult learners**.

This resulted in **126** papers (1.6%) meeting our criteria; it turned out that the requirement of a
randomized controlled trial was a very strict one that most papers failed. Often, reported experiments focused solely on
the developed learning intervention, instead of a comparison between a control and one or more experimental conditions.

Lets now look at a few key summary graphs of those 126 papers (ignoring the learning strategy specifics for now).

Above, we split the 126 papers according to the digital learning environment the reported experiments was conducted in
(take into account that for 2017 we only include papers published by July of that year). *Native environments*, i.e. software designed and implemented specifically for the experiment, turned out to be the most
popular. MOOC-based experiments started to appear in 2014, MTurk-based experiments appeared at around the same time.

How successful (i.e. how often is the intervention reported to perform better than the control condition) are the
different environments? In the graph above and all that follow, a "-" indicates studies reporting a significant negative effect of the intervention; the "+" indicates a significant positive effect of the intervention; and the "o" indicates findings without a statistically significant effect. It turns out that the native environments are the "best" to use to achieve significantly better results; MOOC environments do not fare too well here, more than half of the studies report a non-significant difference between control and experimental conditions. This may not be too surprising as MOOC environments are agnostic to the content topic, while native environments can be designed to fit specific types of content (e.g. language learning).

Above we considered how study participants were incentivized to participate: we found surprisingly many studies without
an incentive/compensation, followed by class-based incentives (credits or requirement for passing a class).

Lastly, we also checked whether the size of the sample has an impact: it turns out that the larger the sample, the more
likely null results appear to occur. One potential explanation here is the heterogeneity of the MOOC population (many
studies in the 501+ partiicpants category are MOOC-based) with respect to age, prior education, study time ...
in contrast to class-based studies.

The paper contains more detailed analyses of the different activce learning strategies and how successful prior studies were, so go ahead and [read it](https://chauff.github.io/documents/publications/CE2018-Davis.pdf).

gha_language: HTML

gha_license_id: MIT


text:
+++
toc = true
title = "SQL"
weight = 1
+++

Because of the flexibility and complexity of SQL syntax and the different handling for SQL queries for distributed databases and single database, not all of the SQLs can be used in Sharding-Sphere.

This section lists the supported SQL syntax and the unsupported SQL syntax for user to look up. In the future, more and more SQL syntax will be supported in Sharding-Sphere.

## Supported SQL

Fully support DQL, DML and DDL. Support pagination, ORDER BY, GROUP BY, aggregation and JOIN(cannot support cross database). Example for DQL:

- Main SELECT

```sql
SELECT select_expr [, select_expr ...] FROM table_reference [, table_reference ...]
[WHERE where_condition]
[GROUP BY {col_name | position} [ASC | DESC]]
[ORDER BY {col_name | position} [ASC | DESC], ...]
[LIMIT {[offset,] row_count | row_count OFFSET offset}]
```

- select_expr

```sql
* |
COLUMN_NAME [AS] [alias] |
(MAX | MIN | SUM | AVG)(COLUMN_NAME | alias) [AS] [alias] |
COUNT(* | COLUMN_NAME | alias) [AS] [alias]
```

- table_reference

```sql
tbl_name [AS] alias] [index_hint_list] |
table_reference ([INNER] | {LEFT|RIGHT} [OUTER]) JOIN table_factor [JOIN ON conditional_expr | USING (column_list)] |
```

## Unsupported SQL

Cannot support brackets redundancy, CASE WHEN、DISTINCT、HAVING、UNION (ALL), can support subquery limited.

Sharding-Sphere supports subquery similar with paging subquery ([Pagination]((/features/sharding/usage-standard/pagination)). No matter how many layers in a subquery, Sharding-Sphere can always find the first subquery that contains the table data, once the sub-subquery containing table data is found in the lower nest, Sharding-Sphere will throw an exception.

For example, the following subquery is ok:

```sql
SELECT COUNT(*) FROM (SELECT * FROM t_order o)
```

But this subquery will cause exceptions:

```sql
SELECT COUNT(*) FROM (SELECT * FROM t_order o WHERE o.id IN (SELECT id FROM t_order WHERE status = ?))
```

Simply speaking, none-functional subquery can be supported in most cases, such as pagination or statistics, etc, but subquery for business is not supported currently.

In addition, subquery containing aggregate functions are not supported currently due to merge constraints.

Can not support SQL which include schema. Because of Sharding-Sphere is manage multiple data sources as one logic data source, so all SQL should be in one logic schema.

## Example

### Supported SQL

| SQL                                                                                | Required condition                  |
| ------------------------------------------------------------------------------------------- | ----------------------------------- |
| SELECT * FROM tbl_name                                                                      |                                     |
| SELECT * FROM tbl_name WHERE (col1 = ? or col2 = ?) and col3 = ?                            |                                     |
| SELECT * FROM tbl_name WHERE col1 = ? ORDER BY col2 DESC LIMIT ?                            |                                     |
| SELECT COUNT(*), SUM(col1), MIN(col1), MAX(col1), AVG(col1) FROM tbl_name WHERE col1 = ?    |                                     |
| SELECT COUNT(col1) FROM tbl_name WHERE col2 = ? GROUP BY col1 ORDER BY col3 DESC LIMIT ?, ? |                                     |
| INSERT INTO tbl_name (col1, col2,...) VALUES (?, ?, ....)                                   |                                     |
| INSERT INTO tbl_name VALUES (?, ?,....)                                                     |                                     |
| INSERT INTO tbl_name (col1, col2, ...) VALUES (?, ?, ....), (?, ?, ....)                    |                                     |
| UPDATE tbl_name SET col1 = ? WHERE col2 = ?                                                 |                                     |
| DELETE FROM tbl_name WHERE col1 = ?                                                         |                                     |
| CREATE TABLE tbl_name (col1 int, ...)                                                       |                                     |
| ALTER TABLE tbl_name ADD col1 varchar(10)                                                   |                                     |
| DROP TABLE tbl_name                                                                         |                                     |
| TRUNCATE TABLE tbl_name                                                                     |                                     |
| CREATE INDEX idx_name ON tbl_name                                                           |                                     |
| DROP INDEX idx_name ON tbl_name                                                             |                                     |
| DROP INDEX idx_name                                                                         |  Configure logic-index in TableRule |

### Unsupported SQL

| SQL                                                                                | Unsupported reason  |
| ------------------------------------------------------------------------------------------- |-------------------- |
| INSERT INTO tbl_name (col1, col2, ...) SELECT col1, col2, ... FROM tbl_name WHERE col3 = ?  | INSERT .. SELECT    |
| INSERT INTO tbl_name SET col1 = ?                                                           | INSERT ..  AND (val1=?)                                         | brackets redundancy |
| SELECT * FROM ds.tbl_name1                                                                  | inculde schema      |

repository: mallocxw/sharding-sphere-doc

repo_name: mallocxw/sharding-sphere-doc


text:
## _Dog Blog_

### _***Kevin Garvey***_

### _Description:_
_A simple HTML page that showcases simple JavaScript and jQuery functionality 03/26/2019_

### Setup/Installation
- _Clone ``https://github.com/kmgarvey279/dog-blog``_
- _Open the index.hrml file in your web browser of choice._

### Specs
_-New activities are added to the 'activity list' when the user enters them into the form and presses the associated button._
_-Selecting any of the three 'color select' buttons will change the background of the page_

### Known Bugs
_None at this time._

### Support and contact details

_Please contact me at<EMAIL_ADDRESS>if you have any questions or comments._

### Technologies Used

_- HTML_
_-JavaScript_
_-jQuery_
_-CSS_

### License

_This software is licensed under the MIT license._
Copyright (c) 2019 **_{Kevin Garvey}_**


text:
---
title: Navigation basics
description: Learn about navigating the user interface of Adobe Dynamic Media Classic.
uuid: ee143695-e42d-479d-b907-fe61ef6cfc0f
contentOwner: Rick Brough
content-type: reference
products: SG_EXPERIENCEMANAGER/Dynamic-Media-Classic
geptopics: SG_SCENESEVENONDEMAND_PK/categories/getting_started
discoiquuid: 825b8949-f961-4ef9-828c-07349013d40d
feature: Dynamic Media Classic
role: User
exl-id: 3ffcfab2-c29d-4b0f-b223-c4a5ca99f21a
topic: Content Management
level: Intermediate
---
# Navigation basics{#navigation-basics}

The Adobe Dynamic Media Classic screen includes three major areas: Global Navigation bar, Asset Library, Asset Filters tab, Browse Panel/Build Panel, and Media Cart (Media Portal only).

![Navigation basics](/help/using/assets/gs_navigation_basics_popup_popup.png)
*Main Adobe Dynamic Media Classic areas*
*A) Global Navigation bar B) Asset Library panel C) Asset Filters tab D) Browse panel E) Media Cart (Media Portal only)*

## Global Navigation bar {#global-navigation-bar}

The Global Navigation bar, located along the top of the screen, offers buttons for performing different tasks:

* **[!UICONTROL Select Company]** - Choose the company you want to access from the menu. This button is not available if you are working with one company.

* **[!UICONTROL Upload]** - Opens the Upload screen so you can upload files from your computer or network to Adobe Dynamic Media Classic. You can upload files from your desktop or via FTP. See [Upload files](/help/using/uploading-files.md).

* **[!UICONTROL Build]** - Choose a Build task from the menu. The Build panel opens so you can create an asset type.

* **[!UICONTROL Publish]** - Opens the Publish screen so you can publish rich media assets to Adobe Dynamic Media Image Servers and the rest of the Adobe Dynamic Media Classic SAAS Infrastructure.

* **[!UICONTROL Jobs]** - Opens the Jobs screen so you can examine records of upload and publish jobs.

* **[!UICONTROL Recent]** - Opens the Recent Activity screen so you can view the names of recently modified assets and recent upload and publish jobs.

* **[!UICONTROL Setup]** - Opens the Setup screen so you can choose setup or administration options for optimizing your use of Adobe Dynamic Media Classic. See [Setup](/help/using/setup-basics.md).

* **[!UICONTROL Help]** Choose a Help option:

  * **[!UICONTROL Help On This Topic]** - Opens the Help system to a page with information about the task you are currently doing.
  * **[!UICONTROL Video Tutorial]** - Accesses videos on specific topics showing you how to get started with each rich media publishing workflow.
  * **[!UICONTROL Help Contents]** - Opens the Help system to the Introduction page. You can select through the Table of Contents to find and view different topics.
  * **[!UICONTROL About]** - Tells you which version of Adobe Dynamic Media Classic you are running.
  * **[!UICONTROL Support]** - Tells you how to get technical support from Adobe Dynamic Media Classic.

* **[!UICONTROL Sign out]** - Exits Adobe Dynamic Media Classic.

## Asset Library {#asset-library}

Use the Asset Library to organize the assets you are working with. You can create folders and subfolders for organizing your assets in the Asset Library.

The top of the Asset Library panel has commands for locating assets. You can search for assets and filter to locate assets. Select the **[!UICONTROL Trash]** icon at the bottom of the Asset Library if you want to examine assets you deleted.

>[!NOTE]
>
>You can select **[!UICONTROL Asset Library]** controls to open or close the Asset Library and get more room to work onscreen. Select the **[!UICONTROL Expand]**/**[!UICONTROL Collapse]** control to expand or close the panel. These controls are on the left side of the panel.

## Browse Panel/Build Panel {#browse-panel-build-panel}

The Browse/Build Panel is where you do much of your work. The functions that are available in this panel depend on whether you are in Browse mode or Build mode.

* **[!UICONTROL Browse mode]** - To view and work with a folder's contents in the Browse Panel, select a folder in the Asset Library. This panel offers the **[!UICONTROL File]**, **[!UICONTROL Preview]**, **[!UICONTROL Select All]**, **[!UICONTROL Select None]**, and **[!UICONTROL Sort]** menus for working with assets. You can also view assets in different ways by moving the slider or select **[!UICONTROL Grid View]**, **[!UICONTROL List View]**, or **[!UICONTROL Detail View]**. Selecting **[!UICONTROL Detail View]** or double-clicking an asset opens the asset in Detail View, where you can perform asset-dependent file operations.

* **[!UICONTROL Build mode]** - Select **[!UICONTROL Build]**, then choose an option so you can start building an eCatalog, Image Set, Spin Set, or one of several other available items on the Build menu. The Build page opens. You can select the assets you want to work with before or after you enter Build mode.

See also [Navigation basics](https://s7d5.scene7.com/s7viewers/html5/VideoViewer.html?videoserverurl=https://s7d5.scene7.com/is/content/&emailurl=https://s7d5.scene7.com/s7/emailFriend&serverUrl=https://s7d5.scene7.com/is/image/&config=Scene7SharedAssets/Universal_HTML5_Video&contenturl=https://s7d5.scene7.com/skins/&asset=S7tutorials/571_Navigation%20Basics_converted%20renamed_Getting%20Started-AVS) training video.

>[!MORELIKETHIS]
>
>* [Manage assets](about-managing-assets.md)
>* [View assets in the Browse Panel](viewing-assets-browse-panel.md#viewing_assets_in_the_browse_panel)
>* [Select assets in the Browse Panel](selecting-assets-browse-panel.md#selecting_assets_in_the_browse_panel)
>* [Search assets](searching-assets.md#searching_assets)

branch_name: refs/heads/main


text:
![Image](/UI/src/assets/images/Hygieia_b.png)
--------------------

### What is Hygieia

#####Pronunciation:  	ee y EE aa (origin Greek)
Hygieia is a single, configurable, easy to use dashboard to visualize near real-time status of the entire delivery pipeline.

Please view a video below to see Hygieia in action

 [![Hygieia Is AWESOME](/media/images/video-shot.png)](https://www.youtube.com/watch?v=SoNTA78j0tc "Hygieia Is AWESOME")

We use tools for everything today and each tool has its own unique dashboard to present information. What is lacking is a near real time consolidated view of the end-to-end delivery pipeline.  This view and a continuous feedback loop is critical to the success of
any DevOps organization.

Capital One Engineers from our DevOps team developed Hygieia keeping in mind the need for such a tool , since none is available commercially out of the box in ready to use state as well as ease of use.
For the past two years, we’ve looked for DevOps visualization tools in the commercial market as well as in the Open Source community

* There are some excellent commercial ALM tools that allow one to visualize traceability between stories, code, tests and builds however they do not cross over from build to deployment

* There are some good commercial Operations tools that provide visibility into server and application run time health, metrics, analytics etc. however they do not provide visibility into the development and build activities

* Open source tools/frameworks such as Grafana provide generic framework to build a dashboard however collecting data from the numerous DevOps tools is still the challenge.

### ScreenShot
![Image](/media/images/hygiea-screenshot.jpg)

repository: tongqqiu/Hygieia

repo_name: tongqqiu/Hygieia


text:
## FanIDE

Netbeans plugin to support the Fanx Language.

It forked from tcolar's FantomIDE (http://fantomide.colar.net/)

### Features
- Syntax Highlighting
- Semantic Error
- Completion with Doc
- Go to declaration
- Debugging
- Outline view

### Screenshot
![image](https://raw.githubusercontent.com/fanx-dev/FanIDE/master/screenshot.png)

### Installing
#### Download

release with fanx : https://github.com/fanx-dev/fanx/releases

#### Install Apache Netbeans(at least 11.3)
https://netbeans.apache.org/download/index.html

#### Install as plugin
Apache Netbeans > Tools > Plugins > Downloaded > Add Plugins

#### Config Fanx/Fantom Env Path
Apache Netbeans > Tools > Preferences > Fantom

#### Set the theme
Apache Netbeans > Tools > Options > Appearance > Look and Feel > FlatLaf Light.

### Build from Source
clone 'https://github.com/fanx-dev/fanx.git'.
```
cd fanx/compiler/compilerx
sh build.sh
```

repository: fanx-dev/fanIDE

repo_name: fanx-dev/fanIDE


text:
## Pillar of OOP (continues)

### Overload and Override

Overload in function is make one function support many input type.

```c++
#include <iostream>
using namespace std;

class printData {
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }
      void print(double  d) {
        cout << "Printing double: " << d << endl;
      }
      void print(string c) {
        cout << "Printing character: " << c << endl;
      }
};

int main(void) {
   printData pd1;

   pd1.print(9); // Integer input
   pd1.print(123.456); // Double input
   pd1.print("Hello PIF !!!"); // Character input

   return 0;
}
```

We use override in derived class, to change all logic code of parent-class's method. It use when we want renew that method or actualize them (virtual method).

```c++
#include <iostream>
using namespace std;

class Parent {
public:
	virtual void func() // "virtual" method
	{
		cout << "func in base class" << endl;
	}
};
// child class inheriting from Parent class
class child : public Parent {
public:
	void func() override // must add "override" keyword
	{	// change logic code of func
		cout << "func in derived class" << endl;
	}
};

int main()
{
	Parent prnt;
    prnt.func();
	child chld;
    chld.func();
    return 0;
}
```

---

### Single and Multiple inherit

`Inheritance` is a method which can derive or construct new classes from the existing class. `Inheritance` allows us to reuse classes by having other classes inherit their members. The class being inherited from is called the `parent class`, `base class`, or `superclass`, and the class doing the inheriting is called the `child class`, `derived class`, or `subclass`.

When we inherited from only one `base class` to only one `derived class`. It's call `single inherit`.

In` multiple inherit`, we have more than one `base class` which are inherited by only one `derived class`.

**Syntax:**

```c++
#include<iostream>
using namespace std;
class base1 {
public:
	base1()
	{
		cout<<"this is base1 class"<<endl;
	}
};
class base2 {
public:
	base2()
	{
		cout<<"this is base2 class"<<endl;
	}
};
class single: public base1 { // Single inherit from class base1
public:
    single()
    {
		cout<<"this class use single inherit"<<endl;
    }
};
class multi: public base1, public base2 {
// Multiple in herit from base1 & base 2
public:
    multi()
    {
		cout<<"this clase use multi inherit"
			<<endl;
    }
};
int main() {
	single foo1;
    multi foo2;
	return 0;
}
```

We not recommend to use `multiple inherrit ` in your code. Because it can become `diamond inherit` (anti-pattern). In below diagram, `method a()` in `class D` doesn't know to run as `class B` or `class C`.

**Example 1:**

```c++
#include<iostream>
using namespace std;
class group { // Base class
protected:
	float group_mark_f = 8.5;
};
class stdnt : public group { // Derive class: "stdnt", inherit from class "group"
    uint32_t stdnt_id;
    float bonus_mark_f = 0;
public:
	stdnt(uint32_t id, float bonus)
	{
		stdnt_id = id;
		if (bonus<=10 || bonus>=0) bonus_mark_f = bonus;
		else cout<<"invalid mark !!!"
				 <<endl;
	}
	void showMark()
 	{
		cout<<"Student "<<stdnt_id<<" have "<<group_mark_f+bonus_mark_f<<"-point"
			<<endl;
	}
};
int main()
{
	stdnt foo(1234, 1.5);
    foo.showMark();
    return 0;
}
```

**Example 2:**

```c++
#include<iostream>
using namespace std;
class animal { // Base1 class
public:
	animal()
	{
		cout<<"This is an animal"<<endl;
    }
};
class fourLegs { // Base2 class
public:
    fourLegs()
    {
		cout<<"have 4 legs"<<endl;
    }
};
class dog : public animal, public fourLegs {
// Derive class
public:
	dog()
    {
		cout<<"this is a dog"<<endl;
    }
};
int main()
{
	dog foo;
    return 0;
}
```

---

### Inheritance vs Aggregation

Inheriting from a `base class` means we don’t have to redefine the information from the `base class` in our `derived classes`. We automatically receive the member `method` and `attribute` of the `base class` through `inheritance`, and then simply add the additional `method` and `attribute` we want. It means that if we ever update or modify the base class, all of our derived classes will automatically inherit the changes.

`Aggregation` is a relationship where one `object` just contains a `reference` to another. The `Container` doesn’t control the life cycle of the `Element`. The `Element` can exist without the `Container` and can be linked to several another `containers` at the same time.

![](.\assets\3_5.png)

**Example:**

```c++
#include<iostream>
#include<string>
using namespace std;
class address{
    public:
        string addrs;
        address(string addrs_i)
        {
            addrs =  addrs_i;
        }
};
class student{
        address *adrs_r; // use reference to create aggregation relation
    public:
        int id;
        string name;
        student( int i, string nm, address*ad)
        {
            id = i;
            name = nm;
            adrs_r = ad;
        }
        void display()
        {
            cout<<id<< "  "<<name<< "  live in: "<<adrs_r->addrs
                <<endl;
        }
};
int main()
{
    address a1= address("Distric 10, Ho Chi Minh city");
    student s1 = student(101, "Foo", &a1);
    s1.display();
    return 0;
}
```

---

### Links references:

**Function Overloading in C++: **[www.geeksforgeeks.org/...](https://www.geeksforgeeks.org/function-overloading-c/)

**Override Keyword in C++: **[www.geeksforgeeks.org/...](https://www.geeksforgeeks.org/override-keyword-c/)

**Inheritance in C++: ** [www.geeksforgeeks.org/...](https://www.geeksforgeeks.org/inheritance-in-c/)

**Aggregation in C++: ** [www.learncpp.com/...](https://www.learncpp.com/cpp-tutorial/aggregation/)


text:
# enjin-test-component

<!-- Auto Generated Below -->

## Dependencies

### Used by

 - [enjin-gallery](../gallery)

### Graph
```mermaid
graph TD;
  enjin-gallery --> enjin-test-component
  style enjin-test-component fill:#f9f,stroke:#333,stroke-width:4px
```

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

*Built with [StencilJS](https://stenciljs.com/)*

repository: catammd/enjin-components

repo_name: catammd/enjin-components


text:
# Welcome

Hello! Thanks for taking an interest in this project and code :)

Contributions to this project are welcome of course, otherwise it wouldn't reside on GitHub 😃 however there's a few things to be aware of:

- This is a personal project, it is not maintained by a team or group.
- It might take a long time for the maintainer(s) to reply to issues or review PRs, they will have have a day jobs & might not have looked at the code for a while.
- The code here is likely to not be bullet proof & production grade, there might be a lack of unit tests or other practices missing from the code base.

# Contributing

There's several ways of contributing to this project, and effort has been made to make this as easy and transparent as possible, whether it's:

- Reporting a bug
- Discussing the current state of the code
- Submitting a fix
- Proposing new features
- Becoming a maintainer

## All code changes happen though pull requests (PRs)

Pull requests are the best way to propose changes to the codebase (using the standard [Github Flow](https://guides.github.com/introduction/flow/index.html)).

Some PR guidance:

- Please keep PRs small and focused on a single feature or change, with discreet commits. Use multiple PRs if need be.
- If you're thinking of adding a feature via a PR please create an issue first where it can be discussed.

High level steps:

1. Fork the repo and create your branch from `master` or `main`.
2. If you've changed APIs, update the documentation.
3. Ensure the test suite (if any) passes (run `make lint`).
4. Make sure your code lints (run `make lint`).
5. Issue that pull request!

## Any contributions you make will be under the MIT Software License

In short, when you submit code changes, your submissions are understood to be under the same [MIT License](http://choosealicense.com/licenses/mit/) that covers the project.

## Report bugs using Github's issues

This project uses GitHub issues to track public bugs. Report a bug by [opening a new issue](./issues/new/choose)

## Write bug reports with detail, background, and sample code

**Great Bug Reports** tend to have:

- A quick summary and/or background
- Steps to reproduce
  - Be specific!
  - Give sample code if you can. Even if it's a snippet
- What you expected would happen
- What actually happens
- Notes (possibly including why you think this might be happening, or stuff you tried that didn't work)

## Use a consistent coding style

Run `make lint-fix` in order to format the code fix any formatting & linting issues that might be present. A [Prettier](https://prettier.io/) configuration file is included

# References

This document was heavily adapted from the open-source contribution guidelines found in [this gist](https://gist.github.com/briandk/3d2e8b3ec8daf5a27a62)

repository: benc-uk/kubeview

gha_language: Vue

repo_name: benc-uk/kubeview


text:
**Advanced Lane Finding Project**

The goals / steps of this project are the following:

* Compute the camera calibration matrix and distortion coefficients given a set of chessboard images.
* Apply a distortion correction to raw images.
* Apply a perspective transform to distorted image ("birds-eye view").
* Use color transforms, gradients, etc., to create a thresholded binary image of warped image.
* Detect lane pixels and fit to find the lane boundary.
* Determine the curvature of the lane and vehicle position with respect to center.
* Warp the detected lane boundaries back onto the original image.
* Output visual display of the lane boundaries and numerical estimation of lane curvature and vehicle position.

[//]: # (Image References)

[image1]: ./output_images/original_vs_correctedboard.png "Undistorted"
[image2]: ./output_images/original_vs_correctedboard.png "Undistorted test_image"
[image3]: ./output_images/warped_img.png "Warp Example"
[image4]: ./output_images/warped_to_binarythreshold.png "Binary Example"
[image5]: ./output_images/window_image.png "Fit Visual"
[image6]: ./output_images/previous_fit_img.png "Output"
[image7]: ./output_images/final_output_of_7.png "Output"
[video1]: https://youtu.be/X9RJ8_MS6HM "Video"

### Writeup / README

### Camera Calibration

#### 1. computing the camera matrix and distortion coefficients.

I start by preparing "object points", which will be the (x, y, z) coordinates of the chessboard corners in the world. Here I am assuming the chessboard is fixed on the (x, y) plane at z=0, such that the object points are the same for each calibration image.  Thus, `objp` is just a replicated array of coordinates, and `objpoints` will be appended with a copy of it every time I successfully detect all chessboard corners in a test image.  `imgpoints` will be appended with the (x, y) pixel position of each of the corners in the image plane with each successful chessboard detection.

I then used the output `objpoints` and `imgpoints` to compute the camera calibration and distortion coefficients using the `cv2.calibrateCamera()` function.  I applied this distortion correction to the test image using the `cv2.undistort()` function and obtained this result:

![alt text][image1]

### Pipeline (single images)

#### 1. Example of a distortion-corrected image.

I have corrected the distorted test image using the function `undistort()` in the note book
![alt text][image2]

#### 2. Performing a perspective transform.

The code for my perspective transform includes a function called `war_img`, which appears in the 7th code cell of the IPython notebook.  The `warp_img()` function takes as inputs an image (`img`), as well as source (`src`) and destination (`dst`) points.  I have written functions source and destination in the same code cell which could give src and dst points. But, I have used the below points in this project.
```python
src = np.float32(
    [[(img_size[0] / 2) - 55, img_size[1] / 2 + 100],
    [((img_size[0] / 6) - 10), img_size[1]],
    [(img_size[0] * 5 / 6) + 60, img_size[1]],
    [(img_size[0] / 2 + 55), img_size[1] / 2 + 100]])
dst = np.float32(
    [[(img_size[0] / 4), 0],
    [(img_size[0] / 4), img_size[1]],
    [(img_size[0] * 3 / 4), img_size[1]],
    [(img_size[0] * 3 / 4), 0]])
```

This resulted in the following source and destination points:

| Source        | Destination   |
|:-------------:|:-------------:|
| 585, 460      | 320, 0        |
| 203, 720      | 320, 720      |
| 1127, 720     | 960, 720      |
| 695, 460      | 960, 0        |

I verified that my perspective transform was working as expected by drawing the `src` and `dst` points onto a test image and its warped counterpart to verify that the lines appear parallel in the warped image.

![alt text][image3]

#### 3. Applying color transforms, gradients or other methods to create a thresholded binary image.

I used a combination of color and gradient thresholds to generate a binary image. Here's an example of my output for this step.

![alt text][image4]

#### 4. Identifying lane-line pixels and fit their positions with a polynomial?

##### for explanation
I have written functions `find_lane_pixels` to detect lane pixels using the sliding window approach and `fit_polynomial` to fit my lane lines with a 2nd order polynomial kinda like this:

![alt text][image5]

Then for faster detection using the previous detected lane coefficients I have written functions `search_around_poly` to search for lane pixels around the previous fitted polynomial with a margin of 100px and `fit_poly` to get updated polynomial coefficients

##### for real time purpose

I have used `find_lane_pixels` to detect lane pixels using the sliding window approach and  `window_search` to fit my lane lines with a 2nd order polynomial kinda like this and this happens only for one frame:

![alt text][image6]

Then for faster detection using the previous detected lane coefficients I have written functions `search_using_prevfit` to search for lane pixels around the previous fitted polynomial with a margin of 100px and `fit_poly` to get updated polynomial coefficients

#### 5. Calculation of the radius of curvature of the lane and the position of the vehicle with respect to center.

I have calculated the radius of curvature and the position fo the vehicle using the knowledge from the lectures and written the code in the cell 21 of the notebook function named as `measure_curvature_real`.

#### 6. Here is an example image of plotted back down onto the road such that the lane area is identified clearly.

To achieve I have written function `path_fill` and uses cv2.polyfill() function. The below is an example of how it looks on the image

![alt text][image7]

---

### Pipeline (video)

1. Read the frame.
2. warp it.
3. apply color tranform and thresholds for binary image.
4. detect the lane pixels just as explained in the case of image.
5. find radius of curvature and offset of the vehicle from centre.
5. draw a path between the lanes.
6. unwarp the frame to original and put radius of curvature and offset on the frame.

####  link to my final video output.  Your pipeline should perform reasonably well on the entire project video (wobbly lines are ok but no catastrophic failures that would cause the car to drive off the road!).

Here's a [link to my video result](https://youtu.be/X9RJ8_MS6HM)

---

### Discussion

#### 1. Briefly discuss any problems / issues you faced in your implementation of this project.  Where will your pipeline likely fail?  What could you do to make it more robust?

Here I'll talk about the approach I took, what techniques I used, what worked and why, where the pipeline might fail and how I might improve it if I were going to pursue this project further.


text:
# Native Go Zookeeper Client Library [![GoDoc](https://godoc.org/github.com/z-division/go-zookeeper?status.svg)](https://godoc.org/github.com/z-division/go-zookeeper/zk)

Package `zk` provides a native client for connecting to a Zookeeper quorum.

This fork incoporates pull requests against the upstream, fixing some key outstanding issues. It also improves support for Zookeeper 3.5 while maintaining a backward-compatible API.

A full list of incorporated pull requests is detailed on the [wiki](https://github.com/z-division/go-zookeeper/wiki).

An [example using this client in a production environment](https://github.com/z-division/go-zookeeper/wiki/Example-Production-Usage)  is listed and annotated on the wiki.

## License
3-clause BSD. See LICENSE file.

repository: z-division/go-zookeeper

gha_language: Go

gha_license_id: NOASSERTION

repo_name: z-division/go-zookeeper


text:
# MNIST GAN
The code here deploys a Google cloud function to show a gallery
of 10 randomly generated MNIST GAN images.

## Arch
* Model was trained in Python and exported as a protocol buffer graph along with frozen weights
* Such model was then imported in Go and put together in a Google Cloud function with Go runtime
* Frontend was designed in Adobe Lightroom
* API was designed in Google protocol buffer (proto3)

## Screenshot
![mnist-gan](https://github.com/sdeoras/lambda/raw/master/gan/art/mnist-gan-gallery.png "MNIST GAN Gallery")

repository: sdeoras/lambda

repo_name: sdeoras/lambda


text:
# illusReproducibility
An illustration of reproducibility

[Preprint](https://www.biorxiv.org/content/10.1101/866301v1)
### Data and scripts for the main analyses
Generally, reproducibility was calculated using a leave-one-out strategy, to avoid sample overlap between testing dataset and the meta-analysis.
* ./run_asy_meta_LeaveOneOut.R, for the main meta-analyses with a leave-one-out procedure
* ./calc_IR_plot_LeaveOneOut.ipynb, for the main analysis with a leave-one-out procedure

All data used in this project are added in this repo now.
* ./doc/dataset_info.csv, information of each dataset
* ./data, this folder includes all data files for the meta-analyses. The original datasets have been used in [Kong et al., 2018](https://doi.org/10.1073/pnas.1718418115), and are also available from the repo [neurohemi](https://github.com/Conxz/neurohemi).
* ./doc/sum_asy_meta.csv, the meta-analysis results with all datasets, also from [Kong et al., 2018](https://doi.org/10.1073/pnas.1718418115)
* ./meta, meta-analysis results with a leave-out-out strategy. (generated with run_asy_meta_LeaveOneOut.R)
* ./tmp

Data and R script for plotting brain maps used in the manuscript.
* brainplot.R, R script for creating brain maps using ggseg
* ggseg.obs.csv, input file for the R script; asymmetry effects of surface area and thickness for each region

In R v3.6.0 and Python 3.7.4

### Old codes for the analysis with all datasets
The original analysis did not use the leave-one-out strategy. The results were indeed very similar, given the large number of datasets.
* run_asy_meta.R, for the original analysis, which did not use the leave-one-out approach.
* calc_IR_plot.ipynb, for the original analysis, which did not use the leave-one-out approach.

### Reference
Kong, Xiang-Zhen, et al. "Mapping cortical brain asymmetry in 17,141 healthy individuals worldwide via the ENIGMA Consortium." Proceedings of the National Academy of Sciences 115.22 (2018): E5154-E5163.

repository: Conxz/illusReproducibility

repo_name: Conxz/illusReproducibility


text:
# he_wallet

A [Helium](https://helium.com) wallet implementation.

This is a simple wallet implementation that enables the creation and
use of an encrypted wallet.

**NOTE:** This wallet is _not_ the absolute safest way to create and
store a private key. No guarantees are implied as to it's safety and
suitability for use as a wallet associated with Helium crypto-tokens.

## Installation

You will need to have the following packages installed on your system:

* Erlang 22.1 or later
* libsodium or libsodium-dev
* Enough of a development environment to be able to compile C-code (make, gcc/clang)

Clone this git repository and build it using:

```
   cd he_wallet
   make
```

The resulting `bin/wallet` executable is ready for use.

## Usage

At any time use `-h` or `--help` to get more help for a command.

### Create a wallet:

```
    bin/wallet create
```

The wallet will be stored in `wallet.key` after specifying an
encryption password on the command line. Options exist to specify the
wallet output file and to force overwriting an existing wallet.

### Verify a wallet:

```
    bin/wallet verify
```

The wallet in `wallet.key` will be verified for decryption after
passing the encryption password on the command line. Options exist to
specify a different wallet file.

### Public Key

```
    bin/wallet info
```

The wallet in `wallet.key` will be read and the public key for the
wallet displayed.

### Balance

```
    bin/wallet balance
```

The wallet in `wallet.key` will be read and the balances for the
wallet retrieved from blockchain using the Helium Explorer API.

## Key Sharding

Sharding wallet keys is supported via [Shamir's Secret Sharing](https://github.com/dsprenkels/sss).  A key
can be broken into N shards such that recovering the original key
needs K distinct shards. This can be done by passing options to
`create`:

```
    bin/wallet create -n 5 -k 3
```

This will create wallet.key.1 through wallet.key.5 (the base name of
the wallet file can be supplied with the `-o` parameter).

When keys are sharded using `verify` will require at least K distinct
keys:

```
    bin/wallet verify -f wallet.key.1 -f wallet.key.2 -f wallet.key.5
```

The password will also be needed when verifying a sharded key.

## Implementation details

A ed25519 key is generated via libsodium. The provided password is run
through PBKDF2, with a configurable number of iterations and a random
salt, and the resulting value is used as an AES key. When sharding is
enabled, an additional AES key is randomly generated and the 2 keys
are combined using a sha256 HMAC into the final AES key.

The private key is then encrypted with AES256-GCM and stored in the
file along with the sharding information, the key share (if
applicable), the AES initialization vector, the PBKDF2 salt and
iteration count and the AES-GCM authentication tag.

gha_language: Erlang


text:
# Diagram
[![Go Reference](https://pkg.go.dev/badge/github.com/esimov/diagram.svg)](https://pkg.go.dev/github.com/esimov/diagram)
[![build](https://github.com/esimov/diagram/actions/workflows/build.yml/badge.svg)](https://github.com/esimov/diagram/actions/workflows/build.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/esimov/diagram)](https://goreportcard.com/report/github.com/esimov/diagram)
[![license](https://img.shields.io/github/license/esimov/diagram)](./LICENSE)

Diagram is a full fledged CLI application to generate hand drawn diagrams from ASCII art.

![screencast](images/screencast.gif)

## Installation

In order to run the application please make sure that Go is installed on your local machine and check if `$GOPATH/bin` is included into the `PATH` directory.

Run the following commands to download the project and build the executable.

```bash
$ git clone https://github.com/esimov/diagram
$ cd diagram
$ go build

# Start the application
$ diagram
```

**Notice:**
The tool requires the [glfw](https://www.glfw.org) graphic library, so make sure that it is installed on your local machine.

For a full list of the required external dependencies check the official documentation of `go-glfw` (https://github.com/go-gl/glfw/blob/master/README.md).

#### Build

A shell script is bundled into the library to mitigate the generation of binary files for the most widespread operating systems, but take care: different dependencies are needed for different operating systems. To build the executable file run:

`$ make all`

## Usage

Once you are inside the terminal application you can create, edit or delete the ASCII diagrams. By pressing `CTRL+d` you can convert the ASCII art into a handwritten diagram. The generated `PNG` file will be saved into the `output` folder relative to the current path.

### Command Line support

The application also supports the generation of hand drawn diagrams directly from command line without to enter into the CLI application.

`$ diagram --help` will show the currently supported options:

```bash
┌┬┐┬┌─┐┌─┐┬─┐┌─┐┌┬┐
 │││├─┤│ ┬├┬┘├─┤│││
─┴┘┴┴ ┴└─┘┴└─┴ ┴┴ ┴
    Version: 1.0.4

CLI app to convert ASCII arts into hand drawn diagrams.

  -font string
    	Path to the font file (default "/Users/esimov/Projects/Go/src/github.com/esimov/diagram/font/gloriahallelujah.ttf")
  -in string
    	Source
  -out string
    	Destination
  -preview
    	Show the preview window (default true)
```

#### CLI Examples

Read input from `sample.txt` and write image to `sample.png` showing a preview window with the hand drawn diagram:

```bash
diagram -in sample.txt -out sample.png
```

Read input from `sample.txt` and write image to `sample.png`, and exit immediately without showing a preview window:

```bash
diagram -in sample.txt -out sample.png -preview=false
```

Generate diagram as above but use a font at a different location:

```bash
diagram -in sample.txt -out sample.png -preview=false -font /path/to/my/font/MyHandwriting.ttf
```

### Key bindings
Key                                     | Action
----------------------------------------|---------------------------------------
Tab                          | Next Panel
Shift+Tab                    | Previous Panel
Ctrl+s                       | Open Save Diagram Modal
Ctrl+s                       | Save Diagram
Ctrl+d                       | Convert Ascii to PNG
Ctrl+x                       | Clear the editor content
Ctrl+z                       | Restore the editor content
PageUp                       | Jump to the top
PageDown                     | Jump to the bottom
Home                         | Jump to the line start
End                          | Jump to the line end
Delete/Backspace            | Delete diagram
Ctrl+c                       | Quit

### Example
| Input | Output |
|:--:|:--:|
|  |  |

The application was tested on **Ubuntu**, **MacOS** and **Windows**.

### Acknowledgements
The ASCII to PNG conversion was ported from [shaky.dart](https://github.com/mraleph/moe-js/blob/master/talks/jsconfeu2012/tools/shaky/web/shaky.dart).

## Dependencies

- https://github.com/jroimartin/gocui
- https://github.com/fogleman/gg
- https://github.com/go-gl/glfw/

## Author

* Endre Simo ([@simo_endre](https://twitter.com/simo_endre))

## License

Copyright © 2017 Endre Simo

This project is under the MIT License. See the [LICENSE](https://github.com/esimov/diagram/blob/master/LICENSE) file for the full license text.

repository: esimov/diagram

repo_name: esimov/diagram


text:
---
layout: kanji
v4: 406
v6: 434
kanji: 帆
keyword: sail
elements: sail, towel, mediocre, drop, wind
strokes: 6
image: E5B886
on-yomi: ハン
kun-yomi: ほ
permalink: /rtk/帆/
prev: 布
next: 幅
---

1) [gsantise] 28-8-2007(156): When stranded at sea, we needed a Sail. The best we had was a TOWEL, which was MEDICORE, only catching a DROP of WIND.

2) [mcbainpc] 25-6-2008(131): A towel makes a mediocre sail.

3) [nolusu] 16-7-2007(21): A sail is a piece of cloth used to catch every drop of wind.

4) [shadolite] 18-3-2008(7): One handy use for a towel, according to the Hitch-Hiker's Guide to the Universe, is as a sail. The effect will be mediocre, however, if there is little wind.

5) [stan_in_japan] 13-2-2012(5): A towel makes a mediocre sail.


text:
-api
--------
Simple API wrapper for [dojo](http://www.dojojs), the node.js application server. As we use it a lot, it has gone
through Closure Compiler on advanced optimizations.

License
-------
Apache License, Version 2.0

repository: willglaub/dojo

repo_name: willglaub/dojo


text:
---
layout: post
title: "Four Months! part i."
published: true
date: 2015-10-20 20:00:00
---

Theo is four months old! All the things we want to say are the things we constantly hear parents—including our own parents—saying all of the time:

- He's getting so big!
- He's growing so fast!
- He's just so freaking cute!
- How did he manage to puke on my pants!?!

While his cuteness and size are both substantial and impressive—his parents are definitely not biased, either—Theo has some more *firsts* to share with y'all:

- Theo visited Yosemite National Park for the first time! It was also Ed's first time and one of the few items on Ed's bucket list.
- Theo stayed in his first hotel! (same trip)
- Theo now can roll from front to back and back to front. And he is scooting a bit (he rolls he legs up behind him like a scorpion and then drags his body forward in some kind of no-legged army crawl). While rolling and inching are not terribly impressive to most adults, these developments are pretty awesome and frightening to us.
- Theo celebrated his mommy's (thirtieth) birthday!
- Theo took his first ambulance ride!  He got a few burns, but Theo is all healed up.
- Theo is now at the stage where he puts **everything** into his mouth. Except for his milk and saliva—those go everywhere but his mouth. We're working on it.
- Theo's eyes appear to have cleared up and gained some strength: he makes eye contact from across the room (again, probably not impressive to non-parents) and sits/contemplates new places like a hawk.
 One of his first such episodes was in the middle of a quiet library.
- Theo watched his first few minutes of football. He screamed as we pulled him away from the television's tractor beam.
- Theo got a bouncy chair! (videos forthcoming)

Now the pictures! Three pages this time!

![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7664.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7681.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7698.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7700.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7702.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7732.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7757.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7758.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7777.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7815.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7837.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7856.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7858.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7888.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7920.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7926.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7944.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7963.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7989.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7993.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF7999.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF8012.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF8014.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF8016.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF8037.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF8056.jpg)
![](https://dl.dropboxusercontent.com/u/72656879/Theo/Sets11to13Favorites/DSCF8074.jpg)


text:
---
title: BBR Congestion Control
date: "2022-05-10"
template: "post"
draft: false
slug: "bbr-congestion-control"
category: "computer networks"
tags:
  - "tcp"
  - "bbr"
description: "A modern congestion control algorithm"
---

TCP is an known transport-layer protocol, but it comes in many variants or flavours of congestion control algorithms. Examples include TCP Tahoe, TCP Reno and TCP New Reno. In modern times (last 20 years), the two more recognised ones are CUBIC and BBR.

## Loss-based Congestion Control

Most of the older congestion control algorithms are **loss-based**, where they reduce the network traffic when packet loss is encountered. Unfortunately, responding to packet loss might not be responding to congestion (the real problem).

When the buffers are shallow, packets can be lost due to transient traffic bursts even when there is no congestion. Reducing the sending rate then results in sub-optimal performance. On the other hand, when buffers are deep, many packets are continuously being sent even when the network is congested. The filled buffers unnecessarily takes up valuable machine resources, a problem known as **bufferbloat**.

## Model-based Congestion Control

[BBR](https://github.com/google/bbr) (Bottleneck Bandwidth and Round-trip propagation time) instead forms a **model** of the internet, by predicting the **optimal network traffic**. It uses two metrics, the maximum bandwidth and minimum RTT, to model a network link. With this knowledge of the network conditions, the algorithm then sends packets based on this optimal network traffic value.

By sending data within the bandwidth limits, BBR achieves *congestion avoidance*. Furthermore, the algorithm does not make knee-jerk reacts to temporary packet loss situations, sending packets at a more stable rate and giving users a better overall throughput.

repository: pikulet/lumen

repo_name: pikulet/lumen


text:
# Docker-Study-Jams
Docker Study Jams 2016 Course materials

######  Author [Ch3ck](https://github.com/Ch3ck); Inspired by [rawkode](https://github.com/rawkode) and [Romain Irani](https://rominirani.com/@iromin)

------

## Docker Fundamentals(Day I)

- [Creating Containers, Part I](1-fundamentals/1.1-Creating Containers, Part I.md)
- [Official Images](1-fundamentals/1.2-Official Images.md)
- [Creating Containers, Part II](1-fundamentals/1.3-Creating Containers, Part II.md)
- [Building Images, Part I](1-fundamentals/1.4-Building Images, Part I.md)
- [Building Images, Part II](1-fundamentals/1.5-Building Images, Part II.md)
- [Publishing images](1-fundamentals/1.6-Publishing Images.md)

## Docker Orchestration in Development (Day II)

- [Docker Compose](2-orchestration-in-development/2.1-docker-compose.md)

## Advanced Docker (Day III)

- [Optimising Images](https://github.com/Docker-Buea/Docker-Study-Jams/blob/master/3-optimising-networking-volume-events/3.1-Optimising-images.md)
- [Networking](https://github.com/Docker-Buea/Docker-Study-Jams/blob/master/3-optimising-networking-volume-events/3.2-Networking-containers.md)
- [Volumes](https://docs.docker.com/engine/tutorials/dockervolumes/)
- [Events](https://docs.docker.com/engine/reference/commandline/events/)

## Docker Orchestration in Production (Day IV)

- [Swarm Mode](https://github.com/Docker-Buea/Docker-Study-Jams/blob/master/4-swarm-mode/4.1-swarm-mode.md)
- [Container Security](https://oreil.ly/ops-perf)

repository: Lin-Tor/Docker-Study-materials

repo_name: Lin-Tor/Docker-Study-materials


text:
Aether CouchDB Sync
==========

Let's mobile clients sync to CouchDB. This server posts from CouchDB to Aether.

Setup
----

- You'll need the `GOOGLE_CLIENT_ID` from lastpass. The client secret is not needed.
- You need to generate a `AETHER_KERNEL_TOKEN` in your Aether Kernel admin interface.
- To run with HAT-Microsensus you need to make sure the 'village' and 'building' surveys have been created in your Aether Kernel instance (the 'name' should be exactly like the document prefixes from the HAT-Microcensus mobile app).

Components
----

### Credentials Exchange

The endpoint `/sync/signin` is set up for the mobile devices to exchange their google identity token for a set of couchdb credentials.

#### POST /sync/signin

```
{ idToken: [GOOGLE JWT], deviceId: [mobile device id, string] }
```

returns

```
{ username: string, password: string, db: string, url: string }
```

In order for a mobile client to gain access, it needs to send a token from a valid email account. In the admin interface, `http://localhost:8666/admin`, you can set valid email addresses under **MobileUser**. **DeviceDB** is handled by the backend and should usually not be touched.

### RQ Import Task

The import task is run as an RQ scheduled job, the interval is defined in `aether/sync/apps.py`. The importer writes its results to the logs, and it also writes meta documents for each imported/errored document. If the main document is `village-aaabbb` the meta document will be written under `village-aaabbb-synced`. This will contain any error messages from importing as well.

**Dev note** when working on the the RQ Task, the container needs to be restarted manually for changes to take effect :(

#### Retreiving Import Errors

Every user database have a design doc `sync/errors` that can be used to look for import errors under `[COUCH_URL]/[DB_NAME]/_design/sync/_view/errors`

#### Matching Mappings and Submissions

Right now surveys are matched on the `name` key in Aether, and the `doc._id` prefix. To run with hat microsurveys, the **village** schema needs to be posted with the name **village** and the **building** schema needs to be posted with that name. Otherwise, those documents won't be imported.

#### Re-trying imports

When going to the admin interface, find a model called DeviceDB. Under the DeviceDB object, reset **last synced seq** to 0. This will make the next import run retry all the documents. Documents that have been successfully imported will not be re-imported.

#### Re-running all imports including the ones that got imported already.
If this is the effect you want, you'll need to delete all the `-synced` documents. You probably wanna write a CouchDB view for this, and then script deleting all the documents.

#### Run the import task manually
The import task can be run manually in development with: `docker-compose run couchdb-sync manage rqenqueue "aether.sync.tasks.import_synced_devices_task"`

Testing sync locally
----

1. Run this repository with `docker-compose up`. You'll need to define the following env vars for sync (see docker-compose.yml): `GOOGLE_CLIENT_ID` and `AETHER_KERNEL_TOKEN`. The Aether Kernel token is created inside the Admin interface of your local aether kernel instance. The Google Client Id can be found in Lastpass or created in [https://console.developers.google.com/apis/credentials?project=hat-microsurveys&organizationId=883350201643](Google API Dev Console). If you create one, you need a Web Application Client for the Google+ Api.

2. Inside the local admin, set up a MobileUser for the email-address you're gonna use.

3. Run/build HAT-Microsurveys. If running in the browser, you'll need to setup `GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET and HAT_AETHER_SERVER_URL`. The URL should be pointing to *the nginx instance in docker-compose (port 8667), not couchdb-sync*. If running on mobile, you need `GOOGLE_CLIENT_ID, and HAT_AETHER_SERVER_URL`. Use the same key as in 1, it should be a Web Application key, **not** a Mobile Application key.

Running tests
-----

To test Aether import, you need to generate a Aether API key in the aether kernel interface and set the `AETHER_KERNEL_TOKEN` and `AETHER_KERNEL_URL` environment variables.

Run all tests with:

`docker-compose run couchdb-sync test`

You can run separate tests using (for example):

`docker-compose run couchdb-sync test aether.sync.tests.test_import`

Everything about the Google Tokens
-------

- Go to [https://console.developers.google.com/apis/credentials](Google Developer Console) and create a project.

- Under **Create Credentials** you have a few different options. You need API keys (good to have different for dev/prod) and OAuth Client IDS.
- Here's the tricky part, the API keys should be for **Web Application**. The Oauth Client Ids should be for **Android**.

- Anywhere you use a GOOGLE_CLIENT ID it should always be the **Web Application** one. The **Android** is **never to be used but it needs to be there**

- When you do the **Android** you need to hash the signing certificate for the App. You need one for debug key and one for release key. Run `keytool -exportcert -list -v -alias release -keystore ./android.release.keystore` (you need to decrypt the release keystore first) and submit the resulting **SHA-1** hash.

repository: zabi-kamran/aether

repo_name: zabi-kamran/aether


text:
Closes #

### Changes

// Describe what you changed

### Screenshots

// Add screenshots here if relevant

### Checklist
Check all that apply

- [ ] Updated documentation to reflect changes
- [ ] Added entry to top of Changelog with link to PR (not issue)
- [ ] Tests pass
- [ ] Peer reviewed and approved
- [ ] Signed [CLA](https://influxdata.com/community/cla/) (if not already signed)

repository: influxdata/clockface

gha_language: TypeScript

repo_name: influxdata/clockface


text:
# Overview

This subordinate charm provides the Octavia Dashboard plugin for use with the OpenStack Dashboard.

# Usage

Example minimal deploy:

    juju deploy openstack-dashboard --config openstack-origin=bionic:rocky
    juju deploy openstack-dashboard-octavia --config openstack-origin=bionic:rocky
    juju add-relation \
        openstack-dashboard:dashboard-plugin octavia-dashboard:dashboard

# Bugs

Please report bugs on [Launchpad](https://bugs.launchpad.net/charm-octavia-dashboard/+filebug).

For general questions please refer to the OpenStack [Charm Guide](https://docs.openstack.org/charm-guide/latest/).


text:
[![Github CI Status](https://github.com/fonttools/openstep-plist/workflows/Wheels/badge.svg)](https://github.com/fonttools/openstep-plist/actions?query=workflow%3A%22Wheels%22)
[![codecov](https://codecov.io/gh/fonttools/openstep-plist/branch/master/graph/badge.svg)](https://codecov.io/gh/fonttools/openstep-plist)
[![PyPI](https://img.shields.io/pypi/v/openstep-plist.svg)](https://pypi.org/project/openstep-plist/)

# openstep-plist

A parser for the "old style" OpenStep property list format (also known as ASCII
plist), written in Cython.
Largely based on the CoreFoundation implementation found here:
https://github.com/opensource-apple/CF/blob/master/CFOldStylePList.c

repository: fonttools/openstep-plist

gha_language: Cython

repo_name: fonttools/openstep-plist


text:
---
title: "Moving to Vulkan (and ES 2.0) instead of OpenGL ES 3.0"
excerpt: "The rationale for the OpenGL ES 3 renderer was having a single codebase for targeting all platforms. This sounds really good in theory and we could say it *almost* works, but..."
categories: ["news"]
author: Juan Linietsky
image: /storage/app/uploads/public/5a9/681/3c1/5a96813c154bd636778829.svg
date: 2018-02-26 00:00:00
---

*Edit:* Changed post title for clarity (previously *Abandoning OpenGL ES 3.0 for Vulkan (and ES 2.0)*). We are not abandoning the current OpenGL ES 3.0 backend *right now*: as outlined in the post, we will start working on a Vulkan backend, which will eventually coexist with the OpenGL ES 2.0 and 3.0 backends - and eventually we might deprecate the OpenGL ES 3.0 backend if Vulkan cuts it.

*Edit 2:* **This article is now outdated.** See [About Godot 4, Vulkan, GLES3 and GLES2](https://godotengine.org/article/about-godot4-vulkan-gles3-and-gles2) for up-to-date information about the planned rendering backends transition.

-----

## The rationale behind OpenGL ES 3.0

The rationale for the OpenGL ES 3 renderer was having a single codebase for targeting all platforms:

* Desktop Linux, Windows, macOS
* Android, iOS
* WebGL 2.0

This sounds really good in theory and we could say it *almost* works. Single codebase for everything is like a dream come true for writing an engine. OpenGL ES 3 provided sufficient functionality to implement most modern rendering features and have something that looks really good (as you can see in all the images and videos we posted).

Yet, in reality, many things did not go as expected.

## Poor mobile support

OpenGL ES 3.0 works, nowadays, in all versions of iOS. On Android, it is supported in [most of the mobile devices](https://developer.android.com/about/dashboards/index.html) in the market. Still, there seems to be a large chunk of them (36% at the time of this writing) that only support OpenGL ES 2.0. This segment is not decreasing fast enough and it seems it will be many years until all devices are fully 3.0 compliant.

Added to that is the terrible driver support for OpenGL ES 3.0 on Android. Most drivers are outright full of bugs, which translates directly to crashes that don't make any sense. Save for Tegra, all other platforms (Adreno, Mali and PowerVR) are buggy and this prevented implementing many potential optimizations for the sake of stability.

This led us to the conclusion that we will need to ship an OpenGL ES 2.0 driver that works in the same way as Godot 2.x (though, including PBR support) in order to achieve maximum compatibility.

This means we have lost a third of the reasons to use OpenGL ES 3.0. Fortunately, Godot 3.1 will come with a new OpenGL ES 2.0 backend that will make Godot work great on mobile again.

## Poor WebGL 2.0 adoption and performance

While WebGL 2 works on Firefox and Chrome (and even runs great on Android mobile), it [still does not](https://caniuse.com/#feat=webgl2) on the other platforms.

Added to that, Godot 3.0 uses quite complex shaders which, while they work fine on WebGL 2, take a long time to compile on Windows due to the Angle GLSL validation and compilation to HLSL.

It seems that for nicer performance and compatibility, we will be forced to use WebGL 1.0 for the time being (based on the upcoming OpenGL ES 2.0 backend).

## Corner cases on NVidia and AMD

While the Godot 3.0 renderer works great for the most part on NVidia and AMD, there are some corner cases (which are pretty difficult to come by) where the OpenGL 3.3 drivers are not optimized as we would like.

These cases are easy to workaround if they ever happen, as they have been the same sort of limitations OpenGL always had (state validation before drawing can take some time).

Still many new users may not be aware of this and do things in less efficient ways, yet expect them to work.. as they do in engines that use Direct3D 12. Again, this is easy to workaround using batching or instancing and does not happen often, but it's one more step.

## Performance on Intel GPUs

Intel GPUs on Windows and macOS have pretty unoptimized OpenGL drivers. The same hardware running Linux has considerably better performance. While the performance hit is not really that bad (you can't expect much from this type of hardware), it's enough that compared to other engines (which may use Direct3D and Metal) Godot may seem a bit slower (e.g. 45 FPS where you would expect 60 if you have an Intel HD 5000).

## Vulkan as an alternative

While none of the problems on the desktop side are serious (users have so far mostly reported performance problems on old Intel IGPs, or extreme corner cases), Vulkan was always a tempting alternative to solve them and to ensure we are much safer from driver bugs (after all, this is what the API was intended for). Still, the lack of support on macOS made it unappealing. Having to write a Metal backend to support this OS is a lot of effort for a platform not used very much.

Khronos announced many months ago the [Vulkan Portability Initiative](https://www.khronos.org/vulkan/portability-initiative), which we found really interesting but was far from being functional. As we mentioned many times in online discussions, moving to it eventually would be ideal.

## MoltenVK goes open source

However, today, in a completely unexpected turn of events, it seems Valve has found an arrangement with the developers of MoltenVK (the commercial and proprietary Vulkan over Metal wrapper), ported Dota 2 to it, and [got it open sourced](https://www.anandtech.com/show/12465/khronos-group-extends-vulkan-portability-with-opensource).

It seems to be a mostly complete Vulkan implementation that runs on macOS and iOS. This pretty much lifts the only barrier we had for moving Godot to it.

## Roadmap changes

As it seems clear that we will be moving to Vulkan on desktop and OpenGL ES 2.0 on mobile and web, further work on the current OpenGL ES 3.0 rendering backend is pointless as it will be rewritten.

For now, we will keep focus on releasing Godot 3.1 with the following main features:

* OpenGL ES 2.0 support
* Proper Mono export support
* Support for 2D meshes, 2D skeletons, and deformable polygons
* New animation tree, with state machine and root motion support
* Blender to Godot exporter that keeps Cycles/Eevee materials (tentatively)
* Features voted in Patreon that do not involve changing 3D rendering

Then afterwards, the rewrite of the rendering backend to use Vulkan will begin. It should not take too long (estimating a couple of months, since there's nothing really new to design), and a new version will be released with this backend (among other features that contributors will keep working on).

For a while, we will then offer three backends to choose from: OpenGL ES 2.0, OpenGL ES 3.0, and Vulkan (the default, when ready). Once the Vulkan backend is well tested and proven to fulfill everything we need it to, the OpenGL ES 3.0 backend might be deprecated and replaced.

This will delay a bit the implementation of new features on the 3D side, but we believe it will be very worth it on the long term. Thanks for the patience!

It is important to note that for games being currently developed with Godot 3.0, **there will not be any compatibility breakage** when moving to Vulkan. This is an internal renderer change, and the exposed APIs and formats will remain the same.

repository: godotengine/godot-website

repo_name: godotengine/godot-website