text:
---
title: Change Title
page_title: Change Title
description: Check our "Change Title" documentation article for the RadRibbonView {{ site.framework_name }} control.
slug: radribbonview-howto-change-title
tags: change,title
published: True
position: 5
---

# Change Title

The purpose of this topic is to show you how to change the __RadRibbonView__'s __Title__
![Rad Ribbon View How To Change The Title](images/RadRibbonView_HowTo_ChangeTheTitle.png)

The RadRibbonView exposes a string property named __Title__, which should be used in such cases.

#### __XAML__

{{region radribbonview-howto-change-title_0}}
	<telerik:RadRibbonView x:Name="xRibbonView" Title="RadRibbonView Demo" />
{{endregion}}

#### __C#__

{{region radribbonview-howto-change-title_1}}
	xRibbonView.Title = "RadRibbonView Demo";
{{endregion}}

#### __VB.NET__

{{region radribbonview-howto-change-title_2}}
	xRibbonView.Title = "RadRibbonView Demo";
{{endregion}}

![Rad Ribbon View How To Change The Title 2](images/RadRibbonView_HowTo_ChangeTheTitle_2.png)

>The __RadRibbonView__'s __Title__ is not entirely changed. Instead, your custom title string is combined with the default "My Application" string. To change the string "My Application" you have to set the __RadRibbonView.ApplciationName__ property to the value you want.

## See Also
 * [Handle double click on application button]({%slug radribbonview-how-to-handle-double-click-on-application-button%})
 * [Add Screen Tips in the Code Behind]({%slug radribbonview-howto-add-screentips-code-behind%})
 * [Change the Application Menu's Image]({%slug radribbonview-how-to-change-the-image-of-the-application-button%})

repository: telerik/xaml-docs

gha_license_id: NOASSERTION

repo_name: telerik/xaml-docs


text:
# Contributing
The PostGraphQL project welcomes all contributors, we want to invest in you so you can invest back into PostGraphQL. Together we can make great software that enables developers to build powerful applications in much less time then would previously have been taken. This document aims to help you get started contributing to the project.

As PostGraphQL may be a piece of critical infrastructure in your app, it is only fair to run the project as [OPEN Open Source](http://openopensource.org/). If you contribute meaningful work to the PostGraphQL project you will be made a collaborator which allows you to create new branches and approve pull requests.

The codebase is documented via READMEs throughout the `src` folder heirarchy, starting with [`src/README.md`](src/README.md). Contributions are also encouraged where these files are missing or inadequate.

To get started hacking on the codebase, make sure Postgres is listening on `localhost:5432`, go to the project folder and then run the following to install all dependencies and PostGraphQL schemas into your default database:

```bash
npm install
scripts/run-kitchen-sink-sql
scripts/dev
```

The first script will install all dependencies of PostGraphQL project. The second script will add the kitchen sink SQL schemas (named `a`, `b`, and `c`) to your default Postgres database at `localhost:5432`. The third script will start PostGraphQL in watch mode and open GraphiQL in your default browser. Whenever you change the PostGraphQL source code, the `scripts/dev` command will restart the PostGraphQL server, just remember to refresh GraphiQL. To manually restart the server type in `rs` and hit enter while `scripts/dev` is running.

If you want to use a different database (e.g. after `createdb postgraphql`), you can do so by passing the database URL to these commands, like this:

```bash
scripts/run-kitchen-sink-sql postgres://localhost:5432/postgraphql
scripts/dev -c postgres://localhost:5432/postgraphql
```

To start PostGraphQL with arguments besides the defaults, just add them to `scripts/dev` like so:

```bash
scripts/dev --schema forum_example --secret keyboard_kitten
```

## Tests
PostGraphQL uses [Jest](http://facebook.github.io/jest/) for testing to take advantage of Jest’s snapshot feature. To run PostGraphQL tests you will need to first create the `postgraphql_test` database in your Postgres instance running on `localhost:5432`. To do so run the following:

```bash
createdb postgraphql_test
```

To run the full test suite run:

```bash
scripts/test
```

When developing PostGraphQL, we recommend using the Jest watch mode feature. So instead you would run tests like so:

```bash
scripts/test --watch
```

Now, only the tests in the files you have changed will be run. There are some slow tests in the PostGraphQL suite so hopefully this should make your development time faster. Once you are in watch mode, Jest will present you with some options you can use to better configure your testing experience.

### Snapshots
PostGraphQL makes use of the Jest snapshot feature. Even when you change small things in PostGraphQL the snapshot tests are likely to fail. This is OK, the snapshot tests are expected to fail. To make the snapshot tests pass again, run `scripts/test --watch` and then press `u` once the initial tests have run. Or run `scripts/test --updateSnapshot`. This will rerun the tests and change the snapshot files in the repository. Commit the changes to the snapshots and the changed snapshots will be reviewed along with the rest of your changes in the PR review process.

### Linting
PostGraphQL uses [TSLint](http://palantir.github.io/tslint/) and Travis CI to test builds and enforce lint rules:
[travis-ci.org/calebmer/postgraphql](https://travis-ci.org/calebmer/postgraphql).

 Commit messages are written in the imperative tense.

Here’s a few examples:

```
feat(ci): run against multiple postgres versions
fix(postgraphql): fix opaque error messages
chore(docs): rename anonymous role to default role
```

When comitting to a branch or a PR you do not need to adhere to this format. However, all commits to the `master` branch *must* be in this format. Often all of the commits in a PR will be squashed and a commit message of this format will be written to summarize the changes.

You must use one of the following types:

- `chore`
- `docs`
- `feat`
- `fix`
- `refactor`
- `style`
- `test`

Common scopes are as follows. You are not required to use any of the following scopes and may instead invent your own. These are just a few that get commonly used.

- `*`
- `postgraphql`
- `graphql`
- `interface`
- `postgres`
- `package`
- `scripts`
- `examples`
- `ci`

license: MIT

repository: orta/postgraphql

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: orta/postgraphql


text:
# NeptuneGL
It's Basically GLFW but I'm gonna add Metal and DirectX.

## Disclaimer
I *STRONGLY* recommend using GLFW instead of this library. Neptune is highly specified to the needs of my game engine. I simply added features to allow use for small OpenGL projects. The only benefit is that it already comes equipped with OpenGL 4.1.

https://garagecrew.org/neptune

## Features
* GLFW-Style Window Creation (macOS Only)
* OpenGL 4.1 Ready
* Keyboard Input
* Callback System

## Future
* Desktop Platform Window Creation
* Cross-API Rendering (No Translation)
* Mobile Windowing??

## Compiling The Library
Neptune uses GNU Make as its build system. It currently only runs on macOS, so that is all it can compile from. To compile, use `cd` to navigate to the directory and run `make` in the terminal. The Neptune library will appear in the bin folder. If you want to compile the examples, run `make example EXAMPLE=project`, project being the name of the example file. (You can also use this to write a test project and avoid the trouble of a proper IDE)

### Neptune Colors
* Neptune Blue - 394C56
* Sandy Brown - 877158
* Moonlight Silver - 808080


text:
![GitHub license](https://img.shields.io/badge/License-MIT-orange)

![Team Rolls](/client/public/img/devlr-v2-slides-cover.png)

### :star2: [Visit devlr on Heroku](https://devlrapp.herokuapp.com/) :star2:

### Table of Contents

- [Program Description](#program-description)
- [Team Members and Rolls](#team-members-and-rolls)
- [New Features](#team-members-and-rolls)
- [Repo and Heroku App Links](#repo-and-heroku-app-links)
- [User Story](#user-story)
- [Acceptance Criteria](#acceptance-criteria)
- [Development](#development-process)
- [Usage](#usage)
- [Screenshots](#screenshots)
- [Functionality](#functionality)
- [devlr Team](#contact-the-devlr-team)

### Program Description
Create a customized profile to display your development background, pinned projects and status updates to share with other developers worldwide. devlr is a social media/portfolio/networking site designed just for developers. There is nothing like it on the open market, the nearest competitor would be Stack Overflow or GitHub for code sharing or Reddit for social interaction.
<br>Our project combines the benefits of GitHub for sharing your code, and Twitter and other social media for sharing your life.
* Using OAuth, our application reaches out to the GitHub API to retrieve projects to highlight your work.
* Using a Mongo database allows users to personalize their pages, leave comments on other user’s pages, like and star comments and projects.
* In future enhancements, our Premiere tier will allow users to connect with other developers to further their careers, such as pairing mentors with junior developers and a job board to post opportunities for career advancement.

### :star2: New Features | devlr2.0
![New features](/client/public/img/devlr-v2-slides-new-features.png)

#### Team Members and Rolls:
![Team Rolls](/client/public/img/devlr-v2-slides-team.png)

#### Repo and Heroku App Links
* [Link to GitHub Repo - https://github.com/brandyquinlan/devlr](https://github.com/brandyquinlan/devlr)
* [Link to Heroku App - https://devlrapp.herokuapp.com](https://devlrapp.herokuapp.com)
* [Link to live App (COMING SOON) - http://devlrapp.com](http://devlrapp.com)

#### User Story

```
AS an authenticated user...
I WANT to use an app to display my web development portfolio as a social media profile
SO THAT I can network with other developers
```

#### Acceptance Criteria

```
As an authenticated user...
WHEN I log into the app
    THEN I can sign up my initial account
WHEN I click to Edit Profile
    THEN I open a modal for data entry
    THEN I can enter my GitHub username
WHEN I connect to a GitHub-authenticated account
    THEN I can pull my GitHub profile information to fill my profile components
WHEN I submit changes to my profile
    THEN I can see those changes posted to my page
WHEN I click the Appearance button
    THEN I can change the color of my dashboard theme
WHEN I type a Wall status
    THEN I can see it posted to the top of my feed
WHEN I click the New button
    THEN a modal opens with a larger post box to submit a status post
WHEN I click Account on the side menu
    THEN a modal opens where I can delete my devlr account
WHEN I click on Logout
    THEN I follow the /logout route and am sent to the root page
```
### Concept
![Concept](/client/public/img/devlr-v2-slides-description.png)

### Development Process
##### Updated Wireframe
![Wireframe](/client/public/img/devlr-v2-slides-wireframe.png)

#### Technologies and Methodologies
![Technologies](/client/public/img/devlr-v2-slides-technologies.png)

#### npm Packages
![npm Packages](/client/public/img/devlr-v2-slides-npm-packages.png)

### Successes and Challenges
![Successes and Challenges](/client/public/img/devlr-v2-slides-success-challenge.png)

### Future Development
![npm Packages](/client/public/img/devlr-v2-slides-future.png)

### Usage
### To begin using devlr, sign up for an account.

- Go to https://devlrapp.herokuapp.com/
- Create an account on the "Signup" screen
- Create a Profile
- Have fun!

### Screenshots
![Screenshots](/client/public/img/devlr-v2-screenshots-for-readme.png)

### Contact the devlr Team
Please contact the devlr team with questions: [devlr.app.team<EMAIL_ADDRESS>
- 🔗 Liz Townsend | GitHub: [liztownd](https://github.com/liztownd)
- 🔗 Kat Buchanan | GitHub: [katsign](https://github.com/katsign)
- 🔗 Vinitha Kumar | GitHub: [selvivini](https://github.com/selvivini)
- 🔗 Keaton Brewster | GitHub: [keaton-brewster](https://github.com/keaton-brewster)
- 🔗 Brandy Quinlan | GitHub: [brandyquinlan](https://github.com/brandyquinlan)
---
This project is MIT licensed. © 2021

repository: brandyquinlan/devlr

branch_name: refs/heads/main

gha_language: JavaScript

repo_name: brandyquinlan/devlr


text:
# OS X Statusbar Countdown

**Deprecated:** Use [BitBar](https://getbitbar.com) with [Countdown plugin](https://getbitbar.com/plugins/Time/countdown.1s.py) instead.

A utility to count down to a date from your OS X menubar/statusbar written in Swift.

<img src="http://i.imgur.com/PDQb7VR.png" width="452" alt="OS X Statusbar Countdown" />

## Installation
Download the binary package from [Releases](https://github.com/bbrks/osx-statusbar-countdown/releases) and run.

If you encounter issues regarding unknown developer, Ctrl+Click on the .app and then click Open.

Alternatively, clone the repo and compile in Xcode :)

## Roadmap

- [x] v0.1 - Countdown displaying in Statusbar
- [ ] v0.2 - Configurable date and title

## License
This project is licensed under the [MIT License](LICENSE).

repository: junyong-tsui/osx-statusbar-countdown

repo_name: junyong-tsui/osx-statusbar-countdown


text:
create-[express](https://www.npmjs.com/package/express)-[typescript](https://www.npmjs.com/package/typescript)-application.

[![Wallaby.js](https://img.shields.io/badge/wallaby.js-powered-blue.svg?style=badge&logo=github)](https://wallabyjs.com/oss/)
## Why _create-express-typescript-application_?

_create-express-typescript-application_ creates a new lightweight express application which is fully customizable for your use case. With the support of TypeScript, it allows a robust NodeJS express app to serve as an RESTful backend server.

There are three modes of _create-express-typescript-application_, mainly:
1. **plain** mode - lightweight express typescript app (--type plain)
2. **typeorm** mode - lightweight express typescript app with typeorm (sqlite included) and swagger (OpenAPI documentation) integrated
3. **prisma** mode - fullweight express typescript app with prisma (relational database ORM) and swagger (OpenAPI documentation) integrated

You are highly recommended to use typeorm template if database is required in this project, otherwise, plain mode.

## Application Details

When you run _create-express-typescript-application_, it sets up a very simple application without junk packages.
The src/app/sample folder shows how easy it is to create new routes.

## Installation

Pre-requisite: Node, npm and git are locally installed.

```sh
$ Just use 'npx'
  Or
$ npm install -g create-express-typescript-application
$ create-express-typescript-application {project-name-without-spaces}
# example (plain lightweight) $ create-express-typescript-application {project-name-without-spaces} -t plain
# example (typeorm lightweight) $ create-express-typescript-application {project-name-without-spaces} -t typeorm
# example (prisma fullweight) $ create-express-typescript-application {project-name-without-spaces} -t prisma
```

## Quick Start

The quickest way to get started is use npx and pass in the name of the project you want to create.
It is invalid to exclude project name.

Create the app:

```bash
$ npx create-express-typescript-application {project-name-without-spaces}
```

Start your express-app in development mode at `http://localhost:8080/`
```bash
$ cd "project name" && npm run dev
```
If swagger is included, you can view the swagger file at `http://localhost:8080/docs`

Or build your application and serve it.
```bash
$ cd "project name" && npm run build && npm start
```

## List of options.

Options:
  -V, --version      output the version number
  -d, --debug        output extra debugging
  -t, --template <type>  specify only prisma or plain or typeorm
  -p, --prisma       define type prisma
  -y, --typeorm       define type typeorm
  -h, --help         display help for command

Prisma options integrates prisma ORM into the lightweight express typescript app.

## Available commands for the server.

- Run the server in development mode: `npm run dev`.
- Build the project for production: `npm run build`.
- Run the production build: `npm start`.

## License

[MIT](LICENSE)


text:
# Using the Authentication REST APIs

The authentication framework API allows you to authenticate users and
retrieve authentication context parameters using REST API calls.

!!! info
    For information on the REST API, supported operations, as well as sample
    requests and responses, see the [authentication framework REST API documentation](https://docs.wso2.com/display/IS510/apidocs/Authentication-framework-apis/).

repository: NipuniBhagya/docs-is

repo_name: NipuniBhagya/docs-is


text:
# rhinocer-os

### Getting Started
I followed the littleosbook guide on setting up the development environment. Their guide can be found at https://littleosbook.github.io/#first-steps

### Emulator
You will need the Bochs x86 emulator to run the OS.
http://bochs.sourceforge.net/

### Compiler/ Assembler
GCC and NASM are used to generate object files. LD is used to link them.

### Compiling and Running

To install dependencies on Ubuntu:
```
sudo apt-get install nasm gcc bochs bochs-x -y
```

To compile:
```
cd rhinocer-os/src
make
```

To run on the Bochs emulator:
```
cd rhinocer-os/src
make run
```

To cleanup temporary files:
```
cd rhinocer-os/src
make clean
```

repository: edcarter/rhinocer-os

repo_name: edcarter/rhinocer-os


text:
---
title: Announcing Contour v1.11.0
excerpt: This blog post covers the new Contour Operator released in v1.11.0.
author_name: Steve Sloka & Daneyon Hansen
# author_avatar: /img/contributors/steve-sloka.png
categories: [kubernetes]
# Tag should match author to drive author pages
tags: ['Steve Sloka & Daneyon Hansen']
date: 2020-12-18
slug: contour_v1110
---

Contour continues to add new features to help you better manage ingress operations in a cluster.
Our latest feature release, Contour 1.11.0, now includes support for a new operator aimed at managing the lifecycle of Contour and its corresponding Envoy instances.

## Contour Operator

__FEATURE STATE:__ Contour v1.11.0 [alpha](https://projectcontour.io/resources/deprecation-policy/)

[Contour Operator](https://github.com/projectcontour/contour-operator/blob/main/README.md) provides a method for packaging,
deploying, and managing Contour. The operator extends the functionality of the Kubernetes API to create, configure, and
manage instances of Contour on behalf of users.
It builds upon the basic Kubernetes resource and controller concepts, but includes domain-specific knowledge to automate the entire lifecycle of Contour.

In Kubernetes, controllers of the control-plane implement control loops that repeatedly compare the desired state of the cluster to its actual state.
If the cluster's actual state doesn’t match the desired state, then the controller takes action to fix the problem.
Contour Operator is a custom Kubernetes controller that uses the `Contour` custom resource (CR) to manage Contour and its dependent components, i.e. the Envoy DaemonSet.
The `contours.operator.projectcontour.io` Custom Resource Definition (CRD) defines the `Contour` CR. A `Contour` is handled by the Kubernetes API just like built-in objects, including interaction via kubectl and inclusion in role-based access control (RBAC) policies.
The following example runs an instance of Contour in namespace `projectcontour` with 2 Deployment replicas:
```
cat <<EOF | kubectl apply -f -
apiVersion: operator.projectcontour.io/v1alpha1
kind: Contour
metadata:
  name: contour-sample
spec: {}
EOF
```

No configuration, i.e. `spec`, is provided since `projectcontour` is the default namespace and `2` is the default number
of replicas for a `Contour`.
The default parameters of the `Contour` can be verified in the same way as any other Kubernetes resource:
```
$ kubectl get contour/contour-sample -o yaml
apiVersion: operator.projectcontour.io/v1alpha1
kind: Contour
metadata:
  name: contour-sample
  namespace: default
...
spec:
  namespace:
    name: projectcontour
    removeOnDeletion: false
  replicas: 2
...
```

Contour Operator continues to monitor the `Contour` CR and provides status on whether the actual state matches the desired state. The following example indicates the `Contour` is available:
```
$ kubectl get contour/contour-sample
NAME             READY   REASON
contour-sample   True    ContourAvailable
```

The `Contour` is now ready to start serving `Ingress` and `HTTPProxy` resources.

Check out the [Getting Started](https://projectcontour.io/getting-started/) guide to learn how to start managing Contour using the operator. Learn more about the planned features of Contour Operator by reviewing the GitHub [Issues](https://github.com/projectcontour/contour-operator/issues).

## XDS Resource `v2` Removed

As mentioned in Contour [1.10](https://projectcontour.io/contour_v1100/#envoy-xds-v3-support) the v2 XDS resource version has been removed from Contour ahead of its removal from Envoy.
Please see the [XDS Migration Guide](https://projectcontour.io/guides/xds-migration/) for upgrading your instances of Envoy/Contour.

Also note that this change applies to any External Auth servers that may be integrated, they need to support XDS version `v3` with this release of Contour.

## Community Thanks!
We’re immensely grateful for all the community contributions that help make Contour even better! For version 1.11, special thanks go out to the following contributors:
- [@invidian](https://github.com/invidian)
- [@alexbrand](https://github.com/alexbrand)
- [@danehans](https://github.com/danehans)
- [@shuuji3](https://github.com/shuuji3)
- [@yoitsro](https://github.com/yoitsro)
- [@bascht](https://github.com/bascht)
- [@tsaarni](https://github.com/tsaarni)
- [@georgegoh](https://github.com/georgegoh)

repository: projectcontour/contour

gha_language: Go

repo_name: projectcontour/contour


text:
---
layout: post
image: /effective-elearning-strategies.png
tags: [elearning-cat, instructional-design-cat]
resource-url: https://community.articulate.com/e-books/5-highly-effective-strategies-for-creating-engaging-e-learning
access: Requires Registration
resource-type: Ebook
resource-org: Articulate
title: "5 Highly Effective Strategies for Creating Engaging E-Learning"
---
{% include JB/setup %}

Want to create more engaging e-learning courses, but aren't sure where to start? In this go-to guide, you'll learn how to attract—and keep—your learners’ attention.

From demystifying visual design principles to uncovering the secret to building great interactions, this e-book shares the pro strategies you need to make more compelling, more engaging, and more effective courses.

gha_language: HTML

gha_license_id: MIT


text:
# setup-automation

> Scripts and methods to setup and automate my workstation.

## Scripts

### AWS Multi-Factor Authentication Login
This script uses an assigned MFA device to generate AWS credentials, namely the
`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` and `AWS_SESSION_TOKEN` environment variables.

##### Setup

The script requires the AWS CLI and jq.
* jq can be installed on a Mac using Homebrew:

    > brew install jq

* Instructions for installing the AWS CLI depend on the version used and can be found
  [here](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html). AWS CLI v1 can be
  installed using `pip`:

    > pip install awscli

##### Usage
The script must be sourced rather than executed as in the example below in order for the exported
environment variables to persist in the active shell session.

* Parameters:
    * `mfa-device-arn`: The ARN of the assigned MFA device.
    * `token`: Up to date one time token from the MFA device.
    * `profile`: Profile name for AWS credentials file. Default: default.
    * `session-duration`: The duration of the session in seconds. Default: 43200 (12 hours).

Example:
```shell script
$ source aws-mfa-login.sh --profile default --mfa-device-arn $AWS_MFA_DEVICE_ARN --token 123456
```

repository: nrfrank/setup-automation

repo_name: nrfrank/setup-automation


text:
# scrapy-crawler
Warning: This project is 2 years old, its parser's logic need to be updated

# Install scrapy via virtualenv

```sh
virtualenv venv -p python3
source venv/bin/activate

pip install -r requirements.txt
```

# Run Scrapy Crawler

```sh
# List spiders
scrapy list

# Crawl baomoi and store items into file
scrapy crawl baomoi -o items.json
```

```sh
# For development: Limit page crawled
scrapy crawl baomoi -s CLOSESPIDER_PAGECOUNT=1

scrapy crawl baomoi -s CLOSESPIDER_PAGECOUNT=1 -o items.json
```

repository: HrTran/scrapy-crawler

gha_language: Python

repo_name: HrTran/scrapy-crawler


text:
# Scripts for reading and writing SPD data on Linux

Make sure the i2c-tools package is installed

    sudo apt-get install i2c-tools

Load the I2C kernel module

    sudo modprobe i2c-dev

Run `i2cdetect -l` to list available I2C/SMBus buses.

Run `i2cdetect -y 0` to scan bus 0. RAM modules should show up at addresses 0x50 to 0x54.

Open `spd_read.sh` and `spd_write.sh` and modify the `ADDRESS` variable for the RAM module SPD you want to read/write. The address starts at 0x50 for the first module up to 0x54 for the forth module.

WARNING: Writing incorrect data to the SPD will prevent your PC from booting!

`spd_read.sh` outputs the SPD data as hex values to stderr, use `./spd_read.sh 2>dump.spd` to save the data to a file.

`spd_write.sh` expects the first argument to be a file with 256 hex values for writing to the RAM SPD - `spd_write.sh dump.spd`.


text:
DEVCON PHILOSOPHY

1. We believe knowledge can be free. Knowledge can be free with the right model. Every knowledge that we teach to a new person, that person is obligated to teach that knowledge to the other new person. Ones can only complete the learning after ones teach it to others.
2.  We let others cover their weakness.

repository: devconcommunity/devconcommunity

repo_name: devconcommunity/devconcommunity


text:
# RuntimeSerializer
Easy to use Runtime Serialization library for C#. At runtime, it creates a new assembly with a new derived type implementing serialization.

Sometimes you might get some objects  which are not marked as serializable but you want to serialize it. But you cannot do it at compile time as the source may not be available for you to edit(eg: .Net defined controls like Buttons, Forms etc or other class defined in 3rd party libraries). This library helps you to create a dynamic object at runtime itself which gives you a serializable version of that object.

The idea is to create a new class at runtime, which derives from existing object's class and implements serialization as well. We then create an object of the new class and copy all items from exiting object to the new object.

The new object now has all values in the existing object and it is serializable as well.

#Usage
Just add RuntimeSerializer.dll and call RuntimeSerializer.GenerateSerializableObject API.
Pass in existing object as paramater and it returns  the new serializable object

For more info on how to use the library, please check the Client.Program file

#Restrictions
As of now it works for only those objects which have a default constructor and the class has to be defined as public

repository: arunsatyarth/RuntimeSerializer

repo_name: arunsatyarth/RuntimeSerializer


text:
---
layout: default
title: ".rultor.yml Reference"
date: 2014-07-13
description:
  Rultor is configured by the .rultor.yml,
  YAML configuration file in root directory of your Github repository
---

Rultor is configured solely through the YAML `.rultor.yml` file stored in the
root directory of your Github repository. There is no control or management
panel. Everything you want to say to Rultor is placed into your `.rultor.yml`
file. The file is mandatory, but all content is optional.

This page contains a complete reference of YAML instructions in alphabetic order.

BTW, you can see a real-life configuration in
[jcabi](https://github.com/jcabi/jcabi) project:
[`rultor.yml`](https://github.com/jcabi/jcabi/blob/master/.rultor.yml).

## Architect

You may wish to define a role of an architect in your project,
who will supervise all merge/release/deploy commands. No command
of that kind will be executed without his confirmation:

{% highlight yaml %}
architect:
  - yegor256
{% endhighlight %}

This is enough to tell Rultor to ask for confirmation before running a build.

## Assets

Very often, you want to add secret files to the directory of your build, right
before it starts. For example, a file with database credentials that should be
deployed to production. You don't want to keep this file in the main repository
since it contains sensitive information, not intended to be accessible by all
programmers.

Put it into another *private* Github repository and inform Rultor that he has to
fetch it from there:

{% highlight yaml %}
assets:
  secret.xml: "yegor256/secret-repo#assets/settings.xml"
{% endhighlight %}

This configuration tells Rultor that it needs to fetch `assets/settings.xml` from
`yegor256/secret-repo` and place it into the `secret.xml` file right before
starting a build.

Keep in mind that every builds starts in `/home/r/repo` directory,
while assets are placed one folder up in the directory tree,
in `/home/r`. This is how the directory layout looks:

{% highlight text %}
/home
  /r
    run.sh
    pid
    status
    stdout
    secret.xml
    /repo
      .rultor.yml
      pom.xml
      ...your other files...
{% endhighlight %}

Don't forget to add [@rultor](https://github.com/rultor) to the list of
collaborators in your private repository. Otherwise Rultor won't be
able to fetch anything from it.

The repository you're fetching assets from must contain `.rultor.yml`
where `friends` section should include the name of repository where
these assets are used, for example:

{% highlight yaml %}
friends:
  - yegor256/rultor
  - jcabi/*
{% endhighlight %}

You may also add `trustee` list there, in order to specify the list
of GitHub users who are allowed to modify the `.rultor.yml` file in the
repository, which is requesting the assets:

{% highlight yaml %}
trustees:
  - yegor256
{% endhighlight %}

This is a very useful and important security measure, which you have to
use when you have more than one contributor to the repository, in order
to make sure the instructions inside `.rultor.yml` don't do anything
illegal with your assets.

## Decrypt

You may want to keep your secret assets right inside your main
repository. In this case, in order to keep them secret, you should
encrypt them using [rultor remote](https://github.com/yegor256/rultor-remote):

{% highlight text %}
$ gem install rultor
$ rultor encrypt -p me/test secret.txt
{% endhighlight %}

Here `me/test` is the name of your Github project.

This code encrypts `secret.txt` file. You will get a new file `secret.txt.asc`.
Commit this file to your repository — nobody will be able
to read it, except Rultor server itself.

Then, instruct Rultor to decrypt it before running your build:

{% highlight yaml %}
decrypt:
  secret.txt: "repo/scrt/secret.txt.asc"
{% endhighlight %}

This configuration tells Rultor to get `scrt/secret.txt.asc` from the
root directory of your repository, decrypt it and save the result
into `secret.txt`. You can access it from your script as `../secret.txt`.
In other words, you can access it at `../secret.txt`, relative
to the repository root from where your script is executed.

## Docker Image

The default Docker image used for all commands is
[`yegor256/rultor-image`](https://registry.hub.docker.com/r/yegor256/rultor-image).

You can change it to, say, `ubuntu:12.10`:

{% highlight yaml %}
docker:
  image: "ubuntu:12.10"
{% endhighlight %}

You can also use your own `Dockerfile` and build your own Docker image,
right before the build. Put `Dockerfile` in some directory in the repository
together with all other Docker files (if you need them) and provide a location
of that directory:

{% highlight yaml %}
docker:
  directory: repo/my-docker-image
{% endhighlight %}

## Environment Variables

You can specify environment variables common for all
commands, for example:

{% highlight yaml %}
env:
  MAVEN_OPTS: "-XX:MaxPermSize=256m -Xmx1g"
merge:
  script:
    - "mvn clean install"
deploy:
  script:
    - "mvn clean deploy"
{% endhighlight %}

In this example, `MAVEN_OPTS` environment variable will be set
for merging and deploying commands.

These environment variables will be available for you by default:

  * `author`: GitHub login of the user who sent the request to Rultor

## Install Script

You can specify script instructions common for all
commands, for example:

{% highlight yaml %}
install:
  - "sudo apt-get install texlive"
merge:
  script:
    - "latex ..."
deploy:
  script:
    - "latex ..."
{% endhighlight %}

In this example, `texlive` package will be installed before merge
and before deploy commands execution.

## Readers

By default, anyone can see your build logs. This may not be desired
for private projects. To grant access to your logs only for
a selected list of users, use this construct:

{% highlight yaml %}
readers:
  - "urn:github:526301"
  - "urn:github:8086956"
  - ...
{% endhighlight %}

Every user is specified as a URN, where his Github account number
stays right after `urn:github:`. You can get your Github account number
by logging into [www.rultor.com](https://www.rultor.com)
and moving mouse over your name, at the
top of the page.

## Run As Root

By default, we create a new user `r` in Docker container and
run your scripts from it. You can instruct Rultor to run
everything as root:

{% highlight yaml %}
docker:
  as_root: true
{% endhighlight %}

This may be a useful option when you are using a custom Docker
container with something different from Ubuntu inside. Switching
to a user `r` may not work smoothly under CentOS, for example. In
this case, just use root.

## SSH

By default, Rultor uses its own servers to run your builds. You can
change that by providing your own SSH coordinates:

{% highlight yaml %}
ssh:
  host: test.example.com
  port: 22
  key: ./keys/id_rsa
  login: test
{% endhighlight %}

Your servers must have `docker` installed. This is the only requirement.

## Merge, Deploy, Release

Three commands `merge`, `deploy` and `release` are
configured similarly in `.rultor.yml`. For example:

{% highlight yaml %}
merge: # or "deploy" or "release"
  commanders:
    - jeff
    - walter
  env:
    MAVEN_OPTS: "-XX:MaxPermSize=256m -Xmx512m"
  script:
    - "sudo apt-get install graphviz"
    - "mvn clean install"
{% endhighlight %}

Environment variables have to be configured, as an associative array with names
of variables as keys, in the `env` property.

Executable script is configured as a list of texts. They will be executed one by
one. If any of them fails, execution stops.

The list of Github accounts able to give commands to Rultor is specified in
`commanders`. By default, only Github repository collaborators can give
commands. Configured commanders don't replace collaborators. In other words,
Github collaborators *and* accounts mentioned here are allowed to give commands.

### Release

There are a few additional configurable parameters for `release` section:

{% highlight yaml %}
release:
  pre: false
  sensitive:
    - my_password.txt
  script: |
    echo "testing..."
    echo "building..."
    echo "packaging..."
{% endhighlight %}

`sensitive` option lists files that must not present in the branch after the release. It is recommended to list your sensitive config files there.

`pre` option if set to `false` will automatically mark the release in GitHub as "final."

### Merge

There are a few additional configurable parameters for `merge` section:

{% highlight yaml %}
merge:
  script: |
    echo "testing..."
    echo "building..."
    echo "packaging..."
  squash: true
  fast-forward: default
{% endhighlight %}

`squash` option may be set to `true` or `false` (default).

`fast-forward` may be either `default`
(`--ff` argument for Git), `only` (`--ff-only`) or `no` (`--no-ff`).
More information about it [here](http://git-scm.com/docs/git-merge).

`rebase` option may be set to `true` or `false` (default). If it's set
to `true`, your fork branch will be "rebased" from origin before the merge.

## Uninstall Script

When you need some script to be executed at the end of
every command (no matter what the result of that command is),
you can configure it via `uninstall`:

{% highlight yaml %}
install: |
  # create a new EC2 instance
merge:
  script: |
    # use EC2 instance for testing
uninstall: |
  # destroy EC2 instance
{% endhighlight %}

This mechanism can be useful when you want to free certain
resources, created during installation.

gha_language: Java


text:
# Javascript Quiz
#### A website that gives students JavaScript questions and grades them.
## Authors
#### Mugacha Gichamba
## Description
#### A student visiting the website will be provided with a list of questions of the javascript language and is expected to choose an answer for each question. After answering all questions and hitting the submit button, the system will display to the student: 1. his/her final score in number and percentage form 2. whether they have excellently, fairly or poorly passed.
## Technologies Used
#### 1. HTML
#### 2. CSS
#### 3. JavaScript
####   -jquery
## Contact
#### Phone:<PHONE_NUMBER>
#### Email<EMAIL_ADDRESS>## License
#### This project is licensed under the MIT License - see the LICENSE.md file for details

repository: MugachaGichamba/javascript-quiz

repo_name: MugachaGichamba/javascript-quiz


text:
# FILE2NPP_MACRO

This is a Python script that converts a file content
into a macro for Notepad++.

> I suggest you to check if you have already
> assigned the hotkey on notepad++ to a command before
> putting the macro inside the ```%appdata%\Notepad++\shortcuts.xml``` file.

> Close and then re-open notepad++ to be able to use the macro.

> Check the ```examples``` folder to see some examples of usage.

## Index
* [Usage](#usage)
* [Description](#description-)
* [Requirements](#requirements-)
* [Changelog](#changelog-)
* [Author](#author-)

## Usage

First you need to execute the script:

    file2npp_macro.py <input> <output> <name> <key> [--shift|--alt|--ctrl]
    file2npp_macro.py -h | --help
    file2npp_macro.py --version

    Options:
    -h --help     Show this screen.
    --version     Show version.
    --shift       Hotkey needs the shift key.
    --alt         Hotkey needs the alt key.
    --ctrl        Hotkey needs the ctrl key.

The parameters are:
* ```<input>```: input file path
* ```<output>```: output file path
* ```<name>```: name of the macro
* ```<key>```: key to press to execute the macro
* A combination of ```--shift```, ```--alt```, ```--ctrl``` if the shift and/or alt and/or
  ctrl key need to be pressed at the same time as the ```<key>``` key to execute the macro

The output file has this format:

```xml
<Macros>
    <Macro name="my_macro" Ctrl="no" Alt="yes" Shift="no" Key="76">
        <Action type="1" message="2170" wParam="0" lParam="0" sParam="" />
        ...
        <Action type="1" message="2170" wParam="0" lParam="0" sParam="" />
    </Macro>
</Macros>
```

The next thing to do is to open the file that contains the macros:

    %appdata%\Notepad++\shortcuts.xml

Add the ```<Macro></Macro>``` element (with its content)
to the ```<Macros></Macros>``` element inside the file.

Close and then re-open notepad++ to be able to use the macro.

Check the ```examples``` folder to see some examples of usage.

[Go to the index](#index)

## Description ![](https://i.imgur.com/wMdaLI0.png)

The script:
1. Parses the parameters
2. Checks if the input file exists
3. Calls the ```make_macro()``` function to create the ```<Macro>``` element:

    make_macro(t_file, t_name, t_ctrl_flag, t_alt_flag, t_shift_flag, t_key)

    Makes a Macro element with the Actions.

    This is a generic Macro element
    ```<Macro name="{{ name }}" Ctrl="{{ ctrl }}" Alt="{{ alt }}" Shift="{{ shift }}" Key="{{ key_code }}">```

    Where:
    * ```{{ name }}``` is the name of macro (```<t_name>```)
    * ```{{ ctrl }}``` = yes if the ctrl key is part of the hotkey (```<t_ctrl_flag>``` = True)

      ```{{ ctrl }}``` = no if it is not part of the hotkey (```<t_ctrl_flag>``` = False)

    * ```{{ alt }}``` = yes if the alt key is part of the hotkey

      ```{{ alt }}``` = no if it is not part of the hotkey (```<t_alt_flag>``` = False)
    * ```{{ shift }}``` = yes if the shift key is part of the hotkey (```<t_alt_flag>``` = True)

      ```{{ shift }}``` = no if it is not part of the hotkey (```<t_shift_flag>``` = False)
    * ```{{ key_code }}``` is the code that corresponds to a key (the key is ```<t_key>```)

            :param str t_file: file to convert to a macro
            :param str t_name: name of the macro
            :param bool t_ctrl_flag: True = the Ctrl key is part of the hotkey
            :param bool t_alt_flag: True = the Alt key is part of the hotkey
            :param bool t_shift_flag: True = the Shift key is part of the hotkey
            :param str t_key: key that is part of the hotkey
            :return E macro_el: lxml element, Macro element

    This function calls the ```key_to_code()``` function to convert ```<t_key>``` to a code
    that is recognized by notepad++:

        key_to_code(t_key)

    Converts a key to the corresponding code
    for notepad++ hotkey.

        :param str t_key: hotkey
        :return int code: hotkey key code

    Then the ```make_macro()``` calls the ```read_file()``` to read each
    line of the input file to thenpass each character
    to ```make_action()``` to make the ```<Action>```
    and appends the returned elements inside the ```<Macro>``` element:

        make_action(t_key):

    Makes an Action element.

    These elements correspond to one keypress.

    A generic Action element is:

    ```<Action type="1" message="2170" wParam="0" lParam="0" sParam="{{ key }}" />```

    Where:
    * ```{{ key }}``` is the pressed key (```<t_key>```)

    > Everything else seems always set to the same values

        :param str t_key: key that is pressed/simulated
        :return E action_el: lxml element, Action element

    ```
    read_file(t_file)
    ```

    Reads the ```<t_file>``` file and yields one line at a time.

        :param str t_file: path to a file to read
        :yield str line: read line

4. Puts the ```<Macro>``` element inside a ```<Macros>``` element.
5. Calls the ```write_macros()``` function to write the ```<Macros>``` element to the output file.
    > If the output file already exist the script asks if you want to overwrite its content

        write_macros(t_file, t_macros_el)

    Writes the Macros element ```<t_macros_el>```
    to the ```<t_file>``` file.

        :param str t_file: output file path
        :param E t_macros_el: lxml element (Macros)

The ```attribute()``` function is used by the ```make_action()``` function:

    attribute(key, value)

Makes an attribute for lxml.

```"key"="value"```

    :param str key: key of the attribute
    :param str value: value of the attribute
    :return dict attr: attribute for lxml

[Go to the index](#index)

## Requirements ![](https://i.imgur.com/H3oBumq.png)
* Python 3
* docopt library (command line parameters manager)
* lxml library (xml parser/builder)

[Go to the index](#index)

## Changelog ![](https://i.imgur.com/SDKHpak.png)

### 2020-03-21 01_01
First version

[Go to the index](#index)

## Author ![](https://i.imgur.com/ej4EVF6.png)
[Stefano Zenaro (mario33881)](https://github.com/mario33881)


text:
---
title: Brew no. 1 - 2F tasting
date: 2020-02-20 00:00:00 0000
---

##### Notes

One of the berry-flavoured bottles was refrigerated on the 5th day of the second fermentation. Expectations
were high for fizziness, but it didn't deliver. The liquid was sifted to remove any berry lumps or baby scoby.
The taste was pleasant and fruity, but not enough acidic component to it and no fizziness at all. The remaining
bottles will be kept fermenting for at least a couple more days.

##### Photos


text:
Bitspeak
========

Converts hex strings to pronounceable words. This may be a good format to print
small identifiers or data that needs to be pronounced. For example, if we
display the `0x44042f` as Base64, it may become something like `hS_$`, which is
pronounced as *"height uppercase ess underline dollar sign"*. With Bitspeak,
the same hex becomes "kupakare", which is much easier to say. That's all...

Usage
-----

```javascript
const bs = require("bitspeak");

console.log(bs.hexToBitspeak6("476ffe")); // "kunizezi"
console.log(bs.bitspeak6ToHex("kunizezi")); // "476ffe"
```

Examples
--------

Bitspeak has two versions, 6-bit and 8-bit per syllable. The 6-bit version is
more accurate since syllables don't get mixed up, but the 8-bit one is more
round since it matches 1 byte per syllable.

Num | Hex | Bs6 | Bs8
--- | --- | --- | ---
16261014 | f81f96 | zipuzigi | zunbowven
4457519 | 44042f | kupakare | kuputow
2609494 | 27d156 | tuzubugi | tinyegen
1529246 | 17559e | bunugiji | binganvaw
14570023 | de5227 | nevutave | yawgitin
2753998 | 2a05ce | tifagedi | taipanmaw
5519699 | 543953 | gupevuke | gudongo
3870500 | 3b0f24 | dimazava | deipowtu
13033781 | c6e135 | muribanu | mensedan
15789528 | f0edd8 | zadinexa | zasuiyun
147010 | 23e42 | pafesupi | pidawki
7313431 | 6f9817 | xesufage | chowvunbin
2213186 | 21c542 | tajagupi | temanki
2145750 | 20bdd6 | tatenegi | taruiyen
4071640 | 3e20d8 | defipexa | dawtayun
1974352 | 1e2050 | befipuka | bawtaga
9512932 | 9127e4 | vakijeva | vetinsu
4517800 | 44efa8 | kudizila | kusowlun
12793805 | c337cd | mamejedu | modinmui
8649854 | 83fc7e | fazemuzi | fozoijaw
14233703 | d93067 | nikepuve | yondachin
2973685 | 2d5ff5 | teguzenu | tuigowzan
5297893 | 50d6e5 | gaduxevu | gayensan
9990788 | 987284 | vibetiba | vunjifu

Pronounce
---------

On the 6-bit version, consonants are picked to maintain an unique map between
the pronounce and the writing. Consonants like `x` should be understood as
`sh` from `shower`, not `x` from `dex`, and consonants like `g` should be read
as in `game`, even when they're followed by an `i` or `e`. Here is a table with
the proper sounds:

consontant | sounds as in
---------- | ------------
p          | **p**ool
b          | **b**ad
t          | **t**ape
d          | **d**ice
k          | **k**ing
g          | **g**ame
x          | **sh**ower
j          | **j**oker
f          | **f**ire
v          | **v**oid
l          | **l**etter
r          | **r**at
m          | **m**ask
n          | **n**inja
s          | **s**un
z          | **z**ebra

Similarly, each syllable must be pronounced in isolation: `kupakare` is `coo -
pa - ka - re`, not `coo - pa - care`.

Specification
-------------

Bitspeak has two flavors, 6-bit and 8-bit per syllable. They use the following tables:

### 6-Bit

```javascript
// Consonants:

0000 -> p
0001 -> b
0010 -> t
0011 -> d
0100 -> k
0101 -> g
0110 -> x
0111 -> j
1000 -> f
1001 -> v
1010 -> l
1011 -> r
1100 -> m
1101 -> n
1110 -> s
1111 -> z

// Vowels:

00 -> a
01 -> u
10 -> i
11 -> e
```

### 8-bit

```javascript
// Consonants:

0000 -> p
0001 -> b
0010 -> t
0011 -> d
0100 -> k
0101 -> g
0110 -> sh
0111 -> j
1000 -> f
1001 -> v
1010 -> l
1011 -> r
1100 -> m
1101 -> y
1110 -> s
1111 -> z

// Vowels:

0000 -> a
0001 -> e
0010 -> i
0011 -> o
0100 -> u
0101 -> an
0110 -> en
0111 -> in
1000 -> un
1001 -> on
1010 -> ai
1011 -> ei
1100 -> oi
1101 -> ui
1110 -> aw
1111 -> ow
```

Why?
----

For when you have to type, vocalize or memorize bytes for whatever reason. For
example, typing a shortened URL in a phone, manually accessing an uuid in a
database, or memorizing a crypto private key. Sure, that should not happen, but
if it does, Bitspeak is supposed to make the process slightly less painful,
as it is arguably easier to write "kupakare" correctly than "hS_$" or "44042f".

1. Typing special characters and uppercase letters in a phone is painful.

2. The pronounce is shorter (kupakare vs heightuppercaseessunderlinedollar vs fourfourzerofourtwoeff).

3. It is gentler to human menory as it has less traps ("was it uppercase or lowercase?").

We're considering using something like that for displaying the unique identifiers of [Formality](https://github.com/moonad/formality) files, a new programming and proof language.

[Relevant XKCD](https://imgs.xkcd.com/comics/password_strength.png)

repository: aadnk/Bitspeak

repo_name: aadnk/Bitspeak


text:
---
author: "Arka Ghosh"
github-id: "anotherArka"
---

### `TwoComplex.scala`

1. `allCollapsed` - Extended definition to give forward and backward maps along with the surface with one vertex.

2. `collapseEdge` -  Extended definition to give forward and backward maps along with the surface with one vertex.

3. `succOpt` - Defined this method which gives the succesor of an edge if possible.

4. `predOpt` - Defined this method which gives the predecessor of an edge if possible.

5. `rotateLeftOpt` - Defined this method which gives the result of rotating an edge by left once when such rotation is possible.

6. `rotateRightOpt` - Defined this method which gives the result of rotating an edge by right once when such rotation is possible.

7. `allEdgesToTheLeftOf` - Defined this method which gives all edges to the left of the given edge.

8. `allEdgesToTheRightOf` - Defined this method which gives all edges to the right of the given edge.

9. `edgesEndingAt` - Defined this method which gives all edges ending at the given vertex.

10. `isEdgeAtBoundary` - Defined this method which checks if the given edge is at the boundary. That is exactly one of `e` and `e.flip` is inside a face of the twocomplex.

11. `isClosedSurface` - Defined this method which checks if the TwoComplex is a closed surface.

12. `isSurfaceWithBoundary` - Defined this method which checks if the TwoComplex is a surface with boundary

13. `addVertices` - Defined this method which, given a set of vertices `vs` gives the TwoComplex got by adding `vs` to the existing TwoComplex. If `vs` is already inside gives the same TwoComplex.

14. `addEdges` - Defined this method which, given a set of edges `eds` gives the TwoComplex got by adding `eds` to the existing TwoComplex. If `eds` is already inside gives the same TwoComplex.

15. `addFaces` - Defined this method which, given a set of faces `fcs` gives the TwoComplex got by adding `fcs` to the existing TwoComplex. If `fcs` is already inside gives the same TwoComplex.

16. `addTwoComplexes` - Defined this method which, gives the result of adding the given set of Twocomplexes to the existing one.

17. `subComplex` - Defined this method which, given a set of vertices gives the subcomplex on the vertices.

18. `slightLeft` - Defined this method which, given an edge `e` rotates left twice and flips it. This is same as rotating left once and then taking the successor.

19. `slightRight` - Given e takes two right rotations and flips it.

20. `angleBetween` - Given two edges `e1` and `e2` gives the angle between them. Where angle is the number of turns to reach `e2` from `e1`. Left turns are considered positive and right turns are considered negative.

### `Quadrangulation.scala`
Defined the `quadrangulate` method which quadrangulates a closed surface and also gives forward and backward maps between edgepaths in the original TwoComplex and its quadragulation.

### `EdgePath.scala`

1. `cyclicalTake` - Defined this method which, given indexes `i` and `j` gives the subpath between `i`-th and `j`-th vertex. Because it works on loops `j` can be less than `i`.

2. `shiftBasePoint` - Defined this method which, In case the EdgePath is a loop, shifts the basePoint to the terminal of the first edge.

3. `loopToGeodesic` - Defined this method which, reduces a loop to geodesic.

4. `intersectionsWith` - Defined this method which, given another loop gives intersection along with signs.

5. `selfIntersection` - Defined this method which gives self intersections with signs.

6. `Intersection` - Defined the `trait` `Intersection`. This helps us to compute intersections between two loops.

### `Examples.scala` and `SphereComplex.scala`

Defined examples of non-surfaces, non-closed-surfaces, sufaces with boundaries.

### `VariousChecks.scala`

1. `Termination` - Defined this method to check terminations of the `quadrangulate` method and correctness of the forward and backward maps.

2. `HomotopyClassesOfPaths` -  Defined this trait which is  equivalence class of paths between two vertices. Contains methods to expand the homotopy classes by adding one more set, merge two homotopy classes, etc.

3. `CollectionOfHomotopyClasses` - Defined this trait which is a collection of homotopy classes between multiple pairs of edges.

4. `starter` - Defines basic homotopy classes by declaring paths in the boundary of a face to be homotopic when they start and end at the same vertex.

5. `mainCourse` - For homotopic pairs of paths `(a,b)` and `(c,d)` declares `a*c` and `b*d` to be homotopic and expands the collection of homotopy classes accordingly.

repository: siddhartha-gadgil/Superficial

repo_name: siddhartha-gadgil/Superficial


text:
---
layout: page
title:  "Neural Network on a Tensor Train"
subheadline:  "by Xiongjie Yu"
teaser: "Redundancy in the weight matrix of a neural network can be much reduced with a tensor network formulation. More than 99% compression rate can be achieved while maintaing accuracy. Tensor train representation of a neural network is compact. This formalism may allow neural networks to be trained on mobile devices."

categories:
    - algorithm
tags:
    - machine learning
image:
   thumb: "tensor_train.png"
header:
    image_fullwidth: "toy_train.jpg"
    caption: by Darren Bockman
---
<!-- Page Content Starts Here -->

## Presentation Summary
In [this presentation][1], I present:

  * Basic idea of tensor train representation of a matrix
  * Compression of a feed-forward neural network

## Examples
  * [example 1][ex1]: compression

## References
  * [Tensorizing Neural Networks][ref1]
  * [Ultimate tensorization: compressing convolutional and FC layers alike][ref2]

### All optimization.
{: .t60 }

{% include list-posts tag='optimization' %}

[1]: {{ site.url }}/assets/slides/Neural_Network_on_a_Tensor_Train.pdf
[ex1]: {{ site.url }}/assets/notebooks/TTNet.html
[ref1]: https://arxiv.org/abs/1509.06569
[ref2]: https://arxiv.org/abs/1611.03214

repository: Paul-St-Young/algorithms

branch_name: refs/heads/gh-pages

repo_name: Paul-St-Young/algorithms


text:
# Material Transition Textures
Many of these values are hardcoded into the shaders and cannot be changed. Any cells containing *unchanged* do use the value from the texture. Equivalent texture values are listed below.
Inkling's ink colors are contained in `/fighter/common/param/effect.prc`.

| Material Effect | Albedo (RGB) | Metalness | Roughness | AO | Specular |
| --- | --- | --- | --- | --- | --- |
| Metal Box | (0.257, 0.257, 0.257) | 1.0 | 0.3 | *unchanged* | 0.0 |
| Ditto | (0.1694, 0.0924, 0.2002) | ??? | ??? | ??? | 0.16 |
| Ink | (0.758027, 0.115859, 0.04) | ??? | ??? | ??? | ??? |
| Gold (Xerneas) | (0.382, 0.304, 0.023) | 1.0 | 0.3 | *unchanged* | 0.0 |

# Material Transition Parameters
Many of these values are hardcoded into the shaders and cannot be changed.

| Material Effect | CustomVector11 | CustomVector30 |
| --- | --- | --- |
| Metal Box | *unused* | *unused* |
| Ditto | ??? | (0.5, 4, 1, 1) |
| Ink | ??? | ??? |
| Gold (Xerneas) | *unused* | *unused* |

repository: ScanMountGoat/Smush-Material-Research

path: /Material Transitions.md

filename: Material Transitions.md

gha_language: Rust

repo_name: ScanMountGoat/Smush-Material-Research


text:
## AWS Deep Learning Containers

AWS [Deep Learning Containers (DLCs)](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html)
are a set of Docker images for training and serving models in TensorFlow, TensorFlow 2, PyTorch, and MXNet.
Deep Learning Containers provide optimized environments with TensorFlow and MXNet, Nvidia CUDA (for GPU instances), and
Intel MKL (for CPU instances) libraries and
are available in the Amazon Elastic Container Registry (Amazon ECR).

The AWS DLCs are used in Amazon SageMaker as the default vehicles for your SageMaker jobs such as training, inference,
transforms etc. They've been tested for machine
learning workloads on Amazon EC2, Amazon ECS and Amazon EKS services as well.

For the list of available DLC images, see [Available Deep Learning Containers Images](available_images.md).
You can find more information on the images available in Sagemaker [here](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-containers-frameworks-deep-learning.html)

## License

This project is licensed under the Apache-2.0 License.

`smdistributed.dataparallel` and `smdistributed.modelparallel` are released under the [AWS Customer Agreement](https://aws.amazon.com/agreement/).

## Table of Contents

 [Getting Started](#getting-started)

 [Building your Image](#building-your-image)

 [Running Tests Locally](#running-tests-locally)

### Getting started

We describe here the setup to build and test the DLCs on the platforms Amazon SageMaker, EC2, ECS and EKS.

We take an example of building a ***MXNet GPU python3 training*** container.

* Ensure you have access to an AWS account i.e. [setup](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
your environment such that awscli can access your account via either an IAM user or an IAM role. We recommend an IAM role for use with AWS.
For the purposes of testing in your personal account, the following managed permissions should suffice:

-- [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)

-- [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)

-- [AmazonEKSClusterPolicy](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEKSClusterPolicy)

-- [AmazonEKSServicePolicy](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEKSServicePolicy)

-- [AmazonEKSServiceRolePolicy](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEKSServiceRolePolicy)

-- [AWSServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)

-- [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)

-- [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)

* [Create](https://docs.aws.amazon.com/cli/latest/reference/ecr/create-repository.html) an ECR repository with the name “beta-mxnet-training” in the us-west-2 region
* Ensure you have [docker](https://docs.docker.com/get-docker/) client set-up on your system - osx/ec2

1. Clone the repo and set the following environment variables:
    ```shell script
    export ACCOUNT_ID=<YOUR_ACCOUNT_ID>
    export REGION=us-west-2
    export REPOSITORY_NAME=beta-mxnet-training
    ```
2. Login to ECR
    ```shell script
    aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.us-west-2.amazonaws.com
    ```
3. Assuming your working directory is the cloned repo, create a virtual environment to use the repo and install requirements
    ```shell script
    python3 -m venv dlc
    source dlc/bin/activate
    pip install -r src/requirements.txt
    ```
4. Perform the initial setup
    ```shell script
    bash src/setup.sh mxnet
    ```
### Building your image

The paths to the dockerfiles follow a specific pattern e.g., mxnet/training/docker/\<version>/\<python_version>/Dockerfile.<processor>

These paths are specified by the buildspec.yml residing in mxnet/buildspec.yml i.e. \<framework>/buildspec.yml.
If you want to build the dockerfile for a particular version, or introduce a new version of the framework, re-create the
folder structure as per above and modify the buildspec.yml file to specify the version of the dockerfile you want to build.

1. To build all the dockerfiles specified in the buildspec.yml locally, use the command
    ```shell script
    python src/main.py --buildspec mxnet/buildspec.yml --framework mxnet
    ```
    The above step should take a while to complete the first time you run it since it will have to download all base layers
    and create intermediate layers for the first time.
    Subsequent runs should be much faster.
2. If you would instead like to build only a single image
    ```shell script
    python src/main.py --buildspec mxnet/buildspec.yml \
                       --framework mxnet \
                       --image_types training \
                       --device_types cpu \
                       --py_versions py3
    ```
3. The arguments —image_types, —device_types and —py_versions are all comma separated list who’s possible values are as follows:
    ```shell script
    --image_types <training/inference>
    --device_types <cpu/gpu>
    --py_versions <py2/py3>
    ```
4. For example, to build all gpu, training containers, you could use the following command
    ```shell script
    python src/main.py --buildspec mxnet/buildspec.yml \
                       --framework mxnet \
                       --image_types training \
                       --device_types gpu \
                       --py_versions py3
    ```

### Upgrading the framework version
1. Suppose, if there is a new framework version for MXNet (version 1.7.0) then this would need to be changed in the
buildspec.yml file for MXNet.
    ```yaml
    # mxnet/buildspec.yml
      1   account_id: &ACCOUNT_ID <set-$ACCOUNT_ID-in-environment>
      2   region: &REGION <set-$REGION-in-environment>
      3   framework: &FRAMEWORK mxnet
      4   version: &VERSION 1.6.0 *<--- Change this to 1.7.0*
          ................
    ```
2. The dockerfile for this should exist at mxnet/docker/1.7.0/py3/Dockerfile.gpu. This path is dictated by the
docker_file key for each repository.
    ```yaml
    # mxnet/buildspec.yml
     41   images:
     42     BuildMXNetCPUTrainPy3DockerImage:
     43       <<: *TRAINING_REPOSITORY
              ...................
     49       docker_file: !join [ docker/, *VERSION, /, *DOCKER_PYTHON_VERSION, /Dockerfile., *DEVICE_TYPE ]

    ```
3. Build the container as described above.
### Adding artifacts to your build context
1. If you are copying an artifact from your build context like this:
    ```dockerfile
    # deep-learning-containers/mxnet/training/docker/1.6.0/py3
    COPY README-context.rst README.rst
    ```
    then README-context.rst needs to first be copied into the build context. You can do this by adding the artifact in
    the framework buildspec file under the context key:
    ```yaml
    # mxnet/buildspec.yml
     19 context:
     20   README.xyz: *<---- Object name (Can be anything)*
     21     source: README-context.rst *<--- Path for the file to be copied*
     22     target: README.rst *<--- Name for the object in** the build context*
    ```
2. Adding it under context makes it available to all images. If you need to make it available only for training or
inference images, add it under training_context or inference_context.
    ```yaml
     19   context:
        .................
     23       training_context: &TRAINING_CONTEXT
     24         README.xyz:
     25           source: README-context.rst
     26           target: README.rst
        ...............
    ```
3. If you need it for a single container add it under the context key for that particular image:
    ```yaml
     41   images:
     42     BuildMXNetCPUTrainPy3DockerImage:
     43       <<: *TRAINING_REPOSITORY
              .......................
     50       context:
     51         <<: *TRAINING_CONTEXT
     52         README.xyz:
     53           source: README-context.rst
     54           target: README.rst
    ```
4. Build the container as described above.
### Adding a package
The following steps outline how to add a package to your image. For more information on customizing your container, see [Building AWS Deep Learning Containers Custom Images](custom_images.md).
1. Suppose you want to add a package to the MXNet 1.6.0 py3 GPU docker image, then change the dockerfile from:
    ```dockerfile
    # mxnet/training/docker/1.6.0/py3/Dockerfile.gpu
    139 RUN ${PIP} install --no-cache --upgrade \
    140     keras-mxnet==<IP_ADDRESS> \
    ...........................
    159     ${MX_URL} \
    160     awscli
    ```
    to
    ```dockerfile
    139 RUN ${PIP} install --no-cache --upgrade \
    140     keras-mxnet==<IP_ADDRESS> \
    ...........................
    160     awscli \
    161     octopush
    ```
2. Build the container as described above.

### Running tests locally
As part of your iteration with your PR, sometimes it is helpful to run your tests locally to avoid using too many
extraneous resources or waiting for a build to complete. The testing is supported using pytest.

Similar to building locally, to test locally, you’ll need access to a personal/team AWS account. To test out:

1. Either on an EC2 instance with the deep-learning-containers repo cloned, or on your local machine, make sure you have
the images you want to test locally (likely need to pull them from ECR)
2. In a shell, export environment variable DLC_IMAGES to be a space separated list of ECR uris to be tested. Also set
CODEBUILD_RESOLVED_SOURCE_VERSION to some unique identifier that you can use to identify the resources your test spins up.
Example:
[Note: change the repository name to the one setup in your account]
    ```shell script
    export DLC_IMAGES="$ACCOUNT_ID.dkr.ecr.us-west-2.amazonaws.com/pr-pytorch-training:training-gpu-py3 $ACCOUNT_ID.dkr.ecr.us-west-2.amazonaws.com/pr-mxnet-training:training-gpu-py3"
    export CODEBUILD_RESOLVED_SOURCE_VERSION="my_unique_test"
    ```
3. Our pytest framework expects the root dir to be test/dlc_tests, so change directories in your shell to be here
    ```shell script
    cd test/dlc_tests
    ```
4. To run all tests (in series) associated with your image for a given platform, use the following command
    ```shell script
    # EC2
    pytest -s -rA ec2/ -n=auto
    # ECS
    pytest -s -rA ecs/ -n=auto

    #EKS
    export TEST_TYPE=eks
    python test/testrunner.py
    ```
    Remove `-n=auto` to run the tests sequentially.
5. To run a specific test file, provide the full path to the test file
    ```shell script
    pytest -s ecs/mxnet/training/test_ecs_mxnet_training.py
    ```
6. To run a specific test function (in this example we use the cpu dgl ecs test), modify the command to look like so:
    ```shell script
    pytest -s ecs/mxnet/training/test_ecs_mxnet_training.py::test_ecs_mxnet_training_dgl_cpu
    ```

7. To run SageMaker local mode tests, launch a cpu or gpu EC2 instance with latest Deep Learning AMI.
   * Clone your github branch with changes and run the following commands
       ```shell script
       git clone https://github.com/{github_account_id}/deep-learning-containers/
       cd deep-learning-containers && git checkout {branch_name}
       ```
   * Login into the ECR repo where the new docker images built exist
       ```shell script
       $(aws ecr get-login --no-include-email --registry-ids ${aws_id} --region ${aws_region})
       ```
   * Change to the appropriate directory (sagemaker_tests/{framework}/{job_type}) based on framework and job type of the image being tested.
       The example below refers to testing mxnet_training images
       ```shell script
       cd test/sagemaker_tests/mxnet/training/
       pip3 install -r requirements.txt
       ```
   * To run the SageMaker local integration tests (aside from tensorflow_inference), use the pytest command below:
       ```shell script
       python3 -m pytest -v integration/local --region us-west-2 \
       --docker-base-name ${aws_account_id}.dkr.ecr.us-west-2.amazonaws.com/mxnet-inference \
        --tag 1.6.0-cpu-py36-ubuntu18.04 --framework-version 1.6.0 --processor cpu \
        --py-version 3
       ```
   * To test tensorflow_inference py3 images, run the command below:
     ```shell script
     python3 -m  pytest -v integration/local \
     --docker-base-name ${aws_account_id}.dkr.ecr.us-west-2.amazonaws.com/tensorflow-inference \
     --tag 1.15.2-cpu-py36-ubuntu16.04 --framework-version 1.15.2 --processor cpu
     ```
8. To run SageMaker remote tests on your account please setup following pre-requisites

    * Create an IAM role with name “SageMakerRole” in the above account and add the below AWS Manged policies
       ```
       AmazonSageMakerFullAccess
       ```
   *  Change to the appropriate directory (sagemaker_tests/{framework}/{job_type}) based on framework and job type of the image being tested."
       The example below refers to testing mxnet_training images
       ```shell script
       cd test/sagemaker_tests/mxnet/training/
       pip3 install -r requirements.txt
       ```
   *  To run the SageMaker remote integration tests (aside from tensorflow_inference), use the pytest command below:
       ```shell script
       pytest integration/sagemaker/test_mnist.py \
       --region us-west-2 --docker-base-name mxnet-training \
       --tag training-gpu-py3-1.6.0 --framework-version 1.6.0 --aws-id {aws_id} \
       --instance-type ml.p3.8xlarge
       ```
   * For tensorflow_inference py3 images run the below command
      ```shell script
      python3 -m pytest test/integration/sagemaker/test_tfs. --registry {aws_account_id} \
      --region us-west-2  --repo tensorflow-inference --instance-types ml.c5.18xlarge \
      --tag 1.15.2-py3-cpu-build --versions 1.15.2
      ```
9. To run SageMaker benchmark tests on your account please perform the following steps:
    * Create a file named `sm_benchmark_env_settings.config` in the deep-learning-containers/ folder
    * Add the following to the file (commented lines are optional):
        ```shell script
        export DLC_IMAGES="<image_uri_1-you-want-to-benchmark-test>"
        # export DLC_IMAGES="$DLC_IMAGES <image_uri_2-you-want-to-benchmark-test>"
        # export DLC_IMAGES="$DLC_IMAGES <image_uri_3-you-want-to-benchmark-test>"
        export BUILD_CONTEXT=PR
        export TEST_TYPE=benchmark-sagemaker
        export CODEBUILD_RESOLVED_SOURCE_VERSION=$USER
        export REGION=us-west-2
        ```
    * Run:
        ```shell script
        source sm_benchmark_env_settings.config
        ```
    * To test all images for multiple frameworks, run:
        ```shell script
        pip install -r requirements.txt
        python test/testrunner.py
        ```
    * To test one individual framework image type, run:
        ```shell script
        # Assuming that the cwd is deep-learning-containers/
        cd test/dlc_tests
        pytest benchmark/sagemaker/<framework-name>/<image-type>/test_*.py
        ```
    * The scripts and model-resources used in these tests will be located at:
        ```
        deep-learning-containers/test/dlc_tests/benchmark/sagemaker/<framework-name>/<image-type>/resources/
        ```

Note: SageMaker does not support tensorflow_inference py2 images.


text:
---
title: Review & Reset Team Package
programPrice: $8500
tags: program
btnText: Enquire Now
---
<!--StartFragment-->

The purpose of the Review and Reset Team package is to work with teams and their leaders to clearly determine the team Culture. Vision and Ways of working.This package is run over a 3-4 week period in order to get the team on board with a common vision and cohesive ways of working.

**Package consists of:**

30 min 1 on 1 session with each team member (<10 team members included & maximum of 2 leaders)

2 hour Ways of Working group session – Working on what processes should Stop, Start and Continue

Recommendations from the Ways of Working group session delivered to leadership.

1 hour Leadership Vision workshop including development of:

* Team Vision statement
* Team RACI matrix developed based on business objectives
* Team structure
* Team key performance indicators

2 hour Team presentation delivered to entire team includes:

* Team observations
* Ways of Working observations and recommendations
* Team vision
* Team structure
* Key performance indicators of how the team will be measured ongoing

<!--EndFragment-->

repository: quantum-t/quantum-web

gha_language: Nunjucks

repo_name: quantum-t/quantum-web


text:
---
title: " Upload denied for project ..."
sidebar: errors_sidebar
permalink: error-upload-denied.html
---
With this error message Gerrit rejects to push a commit if the pushing
user has no upload permissions for the project to which the push was
done.

There are two possibilities how to continue in this situation:

1.  contact one of the project owners and request upload permissions for
    the project (access right
    [*Push*](access-control.html#category_push))

2.  export your commit as a patch using the [git
    format-patch](http://www.kernel.org/pub/software/scm/git/docs/git-format-patch.html)
    command and provide the patch file to one of the project owners

## GERRIT

Part of [Gerrit Error Messages](error-messages.html)

## SEARCHBOX

repository: omunroe-com/gerrihmpg

repo_name: omunroe-com/gerrihmpg


text:
# Usage

The first time `rmapi` is run, it asks you for a registration code, which it then uses to obtain authentication information from reMarkable cloud and stores that in `$HOME/.config/rmapi/rmapi.conf`. Copy that file to `/var/cache/cups/rmapi`.

Then add the printer (after rebuilding NixOS) using

```bash
lpadmin -L 'Cloud Printer' -D 'My reMarkable' -p "reMarkable" -E -v 'remarkable:/Print'
```

You may have to associate the PPD (which has layout information) using your system's print configuration.

repository: timjb/dotfiles

gha_language: Vim script

repo_name: timjb/dotfiles


text:
# Numbers to Words

#### By _**Nicole Sanders, Cassie Musolf**_

## Description

A user enters a number and the program returns the number in a written format

## Specifications

1. User enters a number between 0-9, program returns the number written in word format.
* Input: 1
* Output: One

2. User enters a number between 20-99, program returns the word format.
* Input: 20
* Output: Twenty

3. User enters a number between 100-999, program returns the word format of the number.
* Input: 476
* Output: Four Hundred Seventy Six

4. User enters a number from 10-19
* Input: 11
* Output: Eleven

5. User enters a 0
* Input: 0
* Output: Zero

## Setup/Installation Requirements

* Clone this repository

## Known Bugs

There are no known bugs. Please contact us if any are discovered.

## Support and contact details

Contact Nicole Sanders at<EMAIL_ADDRESS>for any questions, comments, or concerns.

## Technologies Used

* C#
* Nancy Framework
* Razor

### License

*This software is licensed under the MIT license*

Copyright (c) 2017 **_Nicole Sanders, Cassie Musolf_**


text:
# Laravel PHP Framework

[![Build Status](https://travis-ci.org/laravel/framework.svg)](https://travis-ci.org/laravel/framework)
[![Total Downloads](https://poser.pugx.org/laravel/framework/d/total.svg)](https://packagist.org/packages/laravel/framework)
[![Latest Stable Version](https://poser.pugx.org/laravel/framework/v/stable.svg)](https://packagist.org/packages/laravel/framework)
[![Latest Unstable Version](https://poser.pugx.org/laravel/framework/v/unstable.svg)](https://packagist.org/packages/laravel/framework)
[![License](https://poser.pugx.org/laravel/framework/license.svg)](https://packagist.org/packages/laravel/framework)

Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable, creative experience to be truly fulfilling. Laravel attempts to take the pain out of development by easing common tasks used in the majority of web projects, such as authentication, routing, sessions, queueing, and caching.

Laravel is accessible, yet powerful, providing tools needed for large, robust applications. A superb inversion of control container, expressive migration system, and tightly integrated unit testing support give you the tools you need to build any application with which you are tasked.

## Official Documentation

Documentation for the framework can be found on the [Laravel website](http://laravel.com/docs).

## Contributing

Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the [Laravel documentation](http://laravel.com/docs/contributions).

## License

The Laravel framework is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT).

## Screen Shot
check super CRUD From stores controller
https://github.com/islam-reda/Laravel-Social-Blog-Chat-Posts/blob/master/app/Http/Controllers/StoresController.php
in base view
https://github.com/islam-reda/Laravel-Social-Blog-Chat-Posts/blob/master/resources/views/base/index.blade.php

![10-3-2018 1-52-52 PM](https://user-images.githubusercontent.com/38462856/65892743-21587680-e3a7-11e9-8eb9-bf764fc03adc.png)
![10-3-2018 1-53-32 PM](https://user-images.githubusercontent.com/38462856/65892744-21f10d00-e3a7-11e9-8167-abf4c48bb89f.png)
![10-3-2018 1-53-46 PM](https://user-images.githubusercontent.com/38462856/65892745-21f10d00-e3a7-11e9-82c9-2e8484a9726d.png)
![10-3-2018 1-54-00 PM](https://user-images.githubusercontent.com/38462856/65892746-21f10d00-e3a7-11e9-9a12-8b50f7abe647.png)
![10-3-2018 1-54-10 PM](https://user-images.githubusercontent.com/38462856/65892747-21f10d00-e3a7-11e9-814b-389e826743d1.png)
![10-3-2018 1-54-26 PM](https://user-images.githubusercontent.com/38462856/65892749-2289a380-e3a7-11e9-9399-6368568c4a08.png)
![10-3-2018 1-54-37 PM](https://user-images.githubusercontent.com/38462856/65892750-2289a380-e3a7-11e9-81ae-2b2722c684b4.png)
![10-3-2018 1-55-00 PM](https://user-images.githubusercontent.com/38462856/65892751-2289a380-e3a7-11e9-9ca9-e8747edc9b4e.png)
![10-3-2018 1-55-09 PM](https://user-images.githubusercontent.com/38462856/65892752-2289a380-e3a7-11e9-9d76-004c1298df22.png)
![10-3-2018 1-55-18 PM](https://user-images.githubusercontent.com/38462856/65892754-23223a00-e3a7-11e9-8885-938ae9d05e89.png)
![10-3-2018 1-56-07 PM](https://user-images.githubusercontent.com/38462856/65892755-23223a00-e3a7-11e9-9067-b7bc1bc61634.png)
![10-3-2018 1-56-21 PM](https://user-images.githubusercontent.com/38462856/65892756-23223a00-e3a7-11e9-9f09-bffcadaaead2.png)
![10-3-2018 1-56-40 PM](https://user-images.githubusercontent.com/38462856/65892757-23223a00-e3a7-11e9-8a06-8d89f6e25207.png)
![10-3-2018 1-57-03 PM](https://user-images.githubusercontent.com/38462856/65892758-23bad080-e3a7-11e9-8119-e249448ab3a8.png)
![10-3-2018 1-57-34 PM](https://user-images.githubusercontent.com/38462856/65892760-23bad080-e3a7-11e9-9524-57c09f308fb4.png)

gha_language: PHP


text:
# Install

In order to install BullMQ Pro you need to use a NPM token from [taskforce.sh](https://taskforce.sh).

With the token at hand just update or create a ._**npmrc**_ file in your app repository with the following contents:

```
@taskforcesh:registry=https://npm.taskforce.sh/
//npm.taskforce.sh/:_authToken=${NPM_TASKFORCESH_TOKEN}
always-auth=true
```

"NPM\_\_TASKFORCESH\_\_TOKEN" is an environment variable pointing to your token.

Then just install the @taskforcesh/bullmq-pro package as you would install any other package, with npm, yarn or pnpm:

```
yarn add @taskforcesh/bullmq-pro
```

In order to use BullMQ Pro just import the _Pro_ versions of the classes. These classes are subclasses of the open source BullMQ library with new functionality:

```typescript
import { QueuePro, WorkerPro } from '@taskforcesh/bullmq-pro';

const queue = new QueuePro('myQueue');

const worker = new WorkerPro('myQueue', async job => {
  // Process job
});
```

### Using Docker

If you use docker you must make sure that you also add the _**.npmrc**_ file above in your **Dockerfile**:

```docker
WORKDIR /app

ADD .npmrc /app/.npmr
```

repository: taskforcesh/bullmq

gha_language: TypeScript

repo_name: taskforcesh/bullmq


text:
# FSTREESTORE
FSTREESTORE is a *key-value* store that relies entirely on the filesystem and file/folder tree structure. No server.

Here are some features:
- Entirely based on the filesystem
- Five simple operations: `has`, `set`, `get`, `remove`, `list`
- Fast listing with indexing and self sanitizing
- No server required
- A database is just a folder (easy backup, migrate, delete)
- Need multiple stores? Just instanciate multiple `Store` on different folders
- No low-level dependencies
- OK fast
- Keys can contain any utf-8 characters (emoji, Chinese, etc.) and as long as 36 characters
- Values can be `null`, *String*, *Number*, *Array*, *Object*, *TypedArray* (including BigInt and Float64) and *Boolean*
- Numerical values are automatically saved as float or int on 64 bits. Strings are utf-8
- Serialization file format is efficient, versatile and simple

# Install
```
npm install fstreestore
```

# Usage
```js
const Store = require('fstreestore')

// A diretory path is expected here. Can be absolute or relative
let s = new Store('/somewhere/on/filesystem/myDb')

// All the functions are asynchronous and return promises, so they need to be called
// with 'await' from an 'async' function (or with '.then() and .catch())
async function main() {
  // Create the provided directory if necessary
  await s.init()

  // ** Store a key-value

  // with a string
  await s.set('a-key', 'a value')

  // with a number (serialized as int64)
  await s.set('a-key-02', 42)

  // with a number (serialized as float64)
  await s.set('a-key-03', 42.42)

  // with an Object (serialized as JSON string, utf-8)
  await s.set('a-key-04', {firstname: 'Johnny', lastname: 'Bravo'})

  // with an (untyped) Array (serialized as JSON string, utf-8)
  await s.set('a-key-05', [42, 'Johnny Bravo', {foo: 'bar'}])

  // with a typed array (all flavours are possible)
  await s.set('a-key-06', new Uin32Array([12, 13, 14]))
  await s.set('a-key-07', new Float64Array([12.5, 13.3, 14]))

  // with boolean
  await s.set('a-key-08', true)

  // with null
  await s.set('a-key-09', null)

  // ** Retrieve/get a value, under the type they were saved

  let val02 = await s.get('a-key-02') // 42 --> number
  let val07 = await s.get('a-key-07') // Float64Array([12.5, 13.3, 14]) --> typed array
  let val04 = await s.set('a-key-04') // {firstname: 'Johnny', lastname: 'Bravo'} --> object

  // ** List all the available keys

  let allKeys = await s.list()

  // ** remove data, using the key

  await s.remove('a-key-02')
}

main()
```

# Key format
The only constraint for the keys is that they are at least 1 character long and at most 36. Apart from that, all the utf-8 charaters are possible, including emojis, accentuated, Chinese, etc.

Example:
```js
await s.set('drum 🥁', new Float32Array([12, 34.34, Math.PI]))
```

# A word on Errors
FSTREESTORE will throw errors if the provided key does not respect (empty string or longer than 36 characters).

In addition, the `.get()` will throw an error if the key is not existing. To prevent `get` from thowing, it must be used as follow `.get('some key', {throw: false})`, then a `null` value will be returned if `'some key'` does not exist.

# Listing and precautions
Since FSTREESTORE's database are entirely based on the filesystem, it makes all the data easily accessible, but the files and folder in there are to be accessed only by FSTREESTORE and should not be modified manually, otherwise the whole DB might get corrupted.

This is particularly true for the `list` file, that makes the listing possible in a reasonable amount of time. This file keeps an index of what is added and removed. Every time `.list()` is called, the list file gets sanitized under the hood, removing duplicates and deleted keys to keep only the remaining keys. The list is automatically sanitized every 5000 set/remove operations.

# Compatibility
FSTREESTORE was developed and tested on MacOS and probably works on Linux. It was not tested on Windows and I am pretty sure it would not work due to the Windows filesystem being very different from Unix-like fs.

# Why?
The idea first came when I started to look for a *key-value* store that I could run close to a Nodejs app, that did not require a server and was fast and versatile enough. I stumbled upon the excellent **LMDB** (and its [Node wrapper](https://www.npmjs.com/package/node-lmdb)) and started playing with it. Then I wondered how it was working under the hood and looked up B+ trees and stuff like that, and even though **FSTREESTORE** does not use a B+ tree, it's still loosely inspired by this concept. Also, not relying on low level dependencies can prevent having some plateform issues.
Finally, the main reason is that it was fun to to and I was curious about the performance of such a naive store implementation.

# Performance
In the first part, performances were said to be "OK fast", this is obviously relative to one's habit and expectation (as well as one's configuration). In other word, let's just say it's a hobby store that is tailords for hobby projects, and it costs zero in DB server money.
```
CREATE time (ms):<PHONE_NUMBER>17559   iterations: 1000  ops: 1215
READ time (ms):<PHONE_NUMBER>0239944   iterations: 1000  ops: 2685
DELETE time (ms):<PHONE_NUMBER>932213   iterations: 1000  ops: 1534
```

Obviously, these are nowhere near the ~50000 operations per seconds (ops) I get with `LMDB` in the same conditions, but I knew since the very begining that I would never be even close with such a naive approach that relies entirely on creating folders and files on the filesystem!

repository: jonathanlurie/fstreestore

repo_name: jonathanlurie/fstreestore


text:
# Tic-Tac-Toe
This is C++ code for a simple 2 player TIC-TAC-TOE game.
There are two versions available. One for old **Turbo C** compilers and the other for **G++ compiler**.

The code for **Turbo C** compiler is [here](https://github.com/tarunlahrod/Tic-Tac-Toe/blob/master/tL_TicTacToe.CPP) and for **G++ compiler** (for C++11 and C++14) is [here](https://github.com/tarunlahrod/Tic-Tac-Toe/blob/master/tic-tac-toe%20(g%2B%2B%20compatible).cpp).

## Screenshots of Game

repository: tarunlahrod/Tic-Tac-Toe

repo_name: tarunlahrod/Tic-Tac-Toe


text:
**This is a mock repository.**

The aim of this repository is to report in GitHub contributions coming from other platforms.

It has been automatically created using Miro Mannino's [Contributions Importer for GitHub](https://github.com/miromannino/contributions-importer-for-github)

## Notice

The content of this repository contains mock code. This prevents private source code to be leaked. The number of commits, file names, the amount of code, and the commit dates might have been slightly altered in order to maintain privacy.

Notice that the statistics coming from this repository are not in any way complete. Commits only come from other selected git repositories. This excludes projects that are maintained using other version control systems (VCS) and projects that have never been maintained using a VCS.

## Reasons

GitHub shows contributions statistics of its users. There are [several reasons](https://github.com/isaacs/github/issues/627) why this feature could be debatable.

Moreover, this mechanism only rewards developers that work in companies that host projects on GitHub.

Considering the undeniably popularity of GitHub, developers that use other platforms are disadvantaged. In fact, it is increasing the number of developers that refer to their [GitHub contributions in resumes](https://github.com/resume/resume.github.com). Similarly, recruiters [may use GitHub to find talents](https://www.socialtalent.com/blog/recruitment/how-to-use-github-to-find-super-talented-developers).

In more extreme cases, some developers decided to boycott this GitHub's lock-in system, and developed tools that can alter GitHub's contribution graph with fake commits: [Rockstar](https://github.com/avinassh/rockstar) and [Vanity text for GitHub](https://github.com/ihabunek/github-vanity) are good examples.

Instead, the aim of [Contributions Importer for GitHub](https://github.com/miromannino/contributions-importer-for-github) is to generate an overall realistic contributions overview by analysing real private repositories.


text:
# ColorCode (Portable)

*ColorCode (Portable)* is a [Portable Class Library][msdn-pcl] fork of Bashir
Souid's excellent [ColorCode][codeplex-colorcode] library for Syntax
Highlighting.

The goal of this project is to bring ColorCode to new audiences using the
Portable Class Library format.  At the same time, we are taking the latest
version of the tool and making it available on GitHub.  If you are currently
using the .NET Framework 3.5 compatible version then there is no reason to
switch to using this library.

If however, you want to start using Color Code 1.0.2+ with any of the
following platforms then you can consider switching to this portable class
library:

-   ASP.NET Core 1.0
-   Windows 8/10 Desktop
-   Windows Phone 8.1
-   Windows Phone Silverlight 8
-   Xamarin Android
-   Xamarin IOs

The biggest single change in converting this library is the removal of a
dependency on the `System.Drawing` namespace through the introduction of a
similar native .NET object used to represent the CSS colours defined in [CSS
Color Module Level 4][w3c-css4color].

  [msdn-pcl]: https://msdn.microsoft.com/en-us/library/gg597391(v=vs.110).aspx
  [codeplex-colorcode]: https://colorcode.codeplex.com/
  [w3c-css4color]: https://drafts.csswg.org/css-color-4/

license: MS-PL


text:
# omexport -- Oruxmaps track exporter

## Introduction

This program I have written to export all of my Oruxmaps tracks as GPX files for further processing on GPSies.com and Google Earth. Oruxmaps is a great navigation app for the Android platform.

## Usage

Locate the file /sdcard/oruxmaps/oruxmapstracks.db on your Android mobile and copy it to a temporary folder on your PC. Open a command or shell window on your PC, "cd" to the temporary folder and call the python script omexport.py.

### Writing individual GPX files, one for each track

```bash
cd my_temporary_folder

python omexport.py
```

Alternatively specify the location of input database file and output tracks directory:

```bash
python omexport.py --database my/input-directory/oxuxmapstracks.db --tracks my/output-directory/tracks
```

All Oruxmaps-tracks are exported to indvidual GPX files. The GPX files are named by their track name prefixed by their track ID. If you have made use of track folders in Oruxmaps, the output files are also organised in a folder structure. Using the option ```--folder-file``` you can write an additional GPX file (folder.gpx) for each folder, containing all tracks of this folder.

### Writing one GPX file containing all tracks

```bash
cd my_temporary_folder

python omexport.py --combine
```

Alternatively specify the location of input database file and output GPX file:

```bash
python omexport.py --combine --database my/input-directory/oxuxmapstracks.db --track my_output_tracks.gpx
```

All Oruxmaps-tracks are exported to one GPX file. The GPX file contains a track list. Tracks are named by their track name prefixed by their track folder name (if available). This GPX file can be dragged and dropped to Google Earth.

## Requirements

Omexport is based on Python 3.X and the great GPXpy library:

```
pip install gpxpy
```

## License
Omexport is licensed under [MIT-License](https://en.wikipedia.org/wiki/MIT_License)

repository: optiprime/omexport

repo_name: optiprime/omexport


text:
---
layout: post
title:      "The Art of Simplicity-Peace with Complexity:  CLI"
date:       2020-02-16 21:49:40 -0500
permalink:  the_art_of_simplicity-peace_with_complexity_cli
---

Kudos to India.Arie for providing the lyric that I stole for the title of this blog.  It's from her song titled "Wings of Forgiveness", and it talks about NOTHING technical, unless you're some sort of love scientist, so we'll move on.

**Simplicity - That Which is Simple**

In thinking about Object Orientation, the concept is relatively simple.  You create new instances of objects through a blueprint or factory object called a class.  Then you teach that object about itself, and about the "world" around it, by running mini programs called methods.  Each method plays a role in shaping the object's experience while in existence.   Simple, yes?  Well...

**Talk About Your Thick Plots**

If there was only one object in this Object Orientation "world" that gets created, well, that would make things pretty simple, if not painfully boring.  However, the magic behind OO is in the interaction between objects.  Things like the creation of methods that call other methods and store data for use at a later time, and the interdependencies of classes, gems, constants, variables, conditionals, booleans, parsing, iterating and testing and testing and...wait...Where was I?

Oh yes...the magic of Object Orientation...with all that is involved, it can be very exciting, and therein lies the complexity.

This CLI Project is the perfect way to make use of all that is great about Ruby Object Orientation.  That does not mean it was easy, but certainly well worth the struggle, once the code is working.  My project is focused on providing a hair salon customer a way to see a list of available services and to book an appointment for those services.  This involved scraping data from an existing website.  I used the following code snippet:

```
 def self.scrape_services
        html = "http://cieloshairdesign.com/our_services"
        doc = Nokogiri::HTML(open(html))

        doc.css("div.et_pb_text_inner h2").slice(0..3).each do |items|
             name = items.text
             Hairsalon::Service.new(name)
        end
end

```

This is a method, #self.scrape_services, that exists in the Scraper class of the project.  It's purpose is to open the webpage saved in the variable html, using the Nokogiri gem, and then saving the result in a variable called doc.  Once saved, the method will then iterate over the results and create new items to be stored in the @@all class variable in the Services class.  Those items are what comprise the list of services that are presented to the customer for selection.

**The Small Details**

One thing that I have learned from doing this project is that every character counts and 'pry' really is your best friend.  Pry is a wonderful little gem that allows you to interupt your code processing at a certain point, to test if that input will produce the desired result.  The trick is knowing where to place the "binding.pry" entry for the best return.  Fortunately, you can move it around as needed.

Looking forward to the next round!

extension: markdown


text:
---
title: "getServiceResource"
description: "The getServiceResource method retrieves a specific service resource associated with the resource. Service resources are... "
layout: "method"
tags:
    - "method"
    - "sldn"
    - "Resource"
classes:
    - "SoftLayer_Resource_Metadata"
aliases:
    - "/reference/services/softlayer_resource_metadata/getServiceResource"
---
# [SoftLayer_Resource_Metadata](/reference/services/SoftLayer_Resource_Metadata)::getServiceResource

Obtain a specific service resource associated with the resource

## Overview
The getServiceResource method retrieves a specific service resource associated with the resource. Service resources are additional resources that may be used by this resource.

-----

### Parameters
|Name | Type | Description |
| --- | --- | --- |
|serviceName| string| Name of the service to be returned|
|index| integer| Index of the service to be returned, default 0 (the first)|

### Required Headers

### Return Values
* string