text:
# Organization

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**Billing** | Pointer to [**OrganizationBilling**](OrganizationBilling.md) |  | [optional]
**Created** | Pointer to **string** | Date of the organization creation. | [optional] [readonly]
**Description** | Pointer to **string** | Description of the organization. | [optional]
**Name** | Pointer to **string** | The name of the new child-organization, limited to 32 characters. | [optional]
**PublicId** | Pointer to **string** | The `public_id` of the organization you are operating within. | [optional]
**Settings** | Pointer to [**OrganizationSettings**](Organization_settings.md) |  | [optional]
**Subscription** | Pointer to [**OrganizationSubscription**](OrganizationSubscription.md) |  | [optional]

## Methods

### NewOrganization

`func NewOrganization() *Organization`

NewOrganization instantiates a new Organization object
This constructor will assign default values to properties that have it defined,
and makes sure properties required by API are set, but the set of arguments
will change when the set of required properties is changed

### NewOrganizationWithDefaults

`func NewOrganizationWithDefaults() *Organization`

NewOrganizationWithDefaults instantiates a new Organization object
This constructor will only assign default values to properties that have it defined,
but it doesn't guarantee that properties required by API are set

### GetBilling

`func (o *Organization) GetBilling() OrganizationBilling`

GetBilling returns the Billing field if non-nil, zero value otherwise.

### GetBillingOk

`func (o *Organization) GetBillingOk() (*OrganizationBilling, bool)`

GetBillingOk returns a tuple with the Billing field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetBilling

`func (o *Organization) SetBilling(v OrganizationBilling)`

SetBilling sets Billing field to given value.

### HasBilling

`func (o *Organization) HasBilling() bool`

HasBilling returns a boolean if a field has been set.

### GetCreated

`func (o *Organization) GetCreated() string`

GetCreated returns the Created field if non-nil, zero value otherwise.

### GetCreatedOk

`func (o *Organization) GetCreatedOk() (*string, bool)`

GetCreatedOk returns a tuple with the Created field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetCreated

`func (o *Organization) SetCreated(v string)`

SetCreated sets Created field to given value.

### HasCreated

`func (o *Organization) HasCreated() bool`

HasCreated returns a boolean if a field has been set.

### GetDescription

`func (o *Organization) GetDescription() string`

GetDescription returns the Description field if non-nil, zero value otherwise.

### GetDescriptionOk

`func (o *Organization) GetDescriptionOk() (*string, bool)`

GetDescriptionOk returns a tuple with the Description field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetDescription

`func (o *Organization) SetDescription(v string)`

SetDescription sets Description field to given value.

### HasDescription

`func (o *Organization) HasDescription() bool`

HasDescription returns a boolean if a field has been set.

### GetName

`func (o *Organization) GetName() string`

GetName returns the Name field if non-nil, zero value otherwise.

### GetNameOk

`func (o *Organization) GetNameOk() (*string, bool)`

GetNameOk returns a tuple with the Name field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetName

`func (o *Organization) SetName(v string)`

SetName sets Name field to given value.

### HasName

`func (o *Organization) HasName() bool`

HasName returns a boolean if a field has been set.

### GetPublicId

`func (o *Organization) GetPublicId() string`

GetPublicId returns the PublicId field if non-nil, zero value otherwise.

### GetPublicIdOk

`func (o *Organization) GetPublicIdOk() (*string, bool)`

GetPublicIdOk returns a tuple with the PublicId field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetPublicId

`func (o *Organization) SetPublicId(v string)`

SetPublicId sets PublicId field to given value.

### HasPublicId

`func (o *Organization) HasPublicId() bool`

HasPublicId returns a boolean if a field has been set.

### GetSettings

`func (o *Organization) GetSettings() OrganizationSettings`

GetSettings returns the Settings field if non-nil, zero value otherwise.

### GetSettingsOk

`func (o *Organization) GetSettingsOk() (*OrganizationSettings, bool)`

GetSettingsOk returns a tuple with the Settings field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetSettings

`func (o *Organization) SetSettings(v OrganizationSettings)`

SetSettings sets Settings field to given value.

### HasSettings

`func (o *Organization) HasSettings() bool`

HasSettings returns a boolean if a field has been set.

### GetSubscription

`func (o *Organization) GetSubscription() OrganizationSubscription`

GetSubscription returns the Subscription field if non-nil, zero value otherwise.

### GetSubscriptionOk

`func (o *Organization) GetSubscriptionOk() (*OrganizationSubscription, bool)`

GetSubscriptionOk returns a tuple with the Subscription field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetSubscription

`func (o *Organization) SetSubscription(v OrganizationSubscription)`

SetSubscription sets Subscription field to given value.

### HasSubscription

`func (o *Organization) HasSubscription() bool`

HasSubscription returns a boolean if a field has been set.

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

repository: chussenot/datadog-api-client-go

gha_license_id: NOASSERTION

repo_name: chussenot/datadog-api-client-go


text:
# StudentCoursesRestAPI
This Project consists of flask example with mysql connectivity

This project will be used to demonstrate APIs and Docker connectivity in the subsequent versions

## Architecture of the Application
![Preview](./images/StudentFlaskAppArchitecture.png)

branch_name: refs/heads/master

extension: md

gha_language: Python

license_type: permissive


text:
# Burger App - Eat That Burger!

## Introduction
Eat That Burger! is a restaurant app that lets users input the names of burgers they'd like to eat.  Whenever a user submits a burger's name, the app will display the burger on the left side of the page, waiting to be devoured. Each burger in the waiting area also has a Devour It! button. When the user clicks it, the burger will move to the right side of the page. The app will store every burger in a database, whether devoured or not.  Users also have the option to delete devoured burgers from the database.

## Eat That Burger Deployed
[Eat That Burger!](https://lit-shore-22608.herokuapp.com/)

## Technology Used
1. HTML
2. CSS
3. Javascript/jQuery
4. Express
5. Handlebars
6. Node
7. Heroku
8. MySql

license: MIT

repository: KateALaney/Burger-App

gha_language: JavaScript

gha_license_id: MIT

repo_name: KateALaney/Burger-App


text:
gulp-web-modules plugin used to precompile and include handlebars templates

Usage
-----
Your handlebars template should be located in a file called *templates* within your section directory

    {project root}
    |-- sections
        |-- foo
            |-- templates
                |-- myTemplate.hbs

And you will be able to access your templates within the section using the following code

    var data = {foo: 'bar'};
    var content = require('./templates')(data);

Install
------
Add this plugin to the gulp-web-module reference in your gulpfile
    var gulpWebModules = require('gulp-web-modules'),
        gwmHandlebars = require('gwm-handlebars');

    gulpWebModules({
      plugins: [
        gwmHandlebars(options[, {handlebars instance}])
      ]
    }).injectTasks(gulp);

Options
-------
The options that can be provided when creating this plugin is a hash with the following values
* *ext*: (default "hbs") the file extension
* *fileName* (default "templates") the directory name (and module name when retrieving the templates)

The handlebars instance can be provided.  If not, handlebars ~1.3 will be used.


text:
# Open Library Go Interface
[![GoDoc](https://godoc.org/github.com/exlibris-fed/openlibrary-go?status.svg)](https://godoc.org/github.com/exlibris-fed/openlibrary-go) ![GitHub tag (latest SemVer)](https://img.shields.io/github/v/tag/exlibris-fed/openlibrary-go) [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](code_of_conduct.md)

A package for interacting with the [Open Library](https://github.com/internetarchive/openlibrary) API.

Very very much a work in progress.

repository: exlibris-fed/openlibrary-go

gha_language: Go

repo_name: exlibris-fed/openlibrary-go


text:
# gofish-bot

Keeping the fish-food fresh

[![Report](https://goreportcard.com/badge/github.com/gofish-bot/gofish-bot?style=flat-square)](https://goreportcard.com/report/github.com/gofish-bot/gofish-bot)
[![Maintained](https://img.shields.io/maintenance/yes/2021?style=flat-square)](https://github.com/gofish-bot/gofish-bot)
[![License](https://img.shields.io/github/license/gofish-bot/gofish-bot?style=flat-square)](https://github.com/gofish-bot/gofish-bot/blob/master/LICENSE)
[![GitHub branch checks state](https://img.shields.io/github/checks-status/gofish-bot/gofish-bot/master?label=Build%20and%20Test&style=flat-square)](https://github.com/gofish-bot/gofish-bot/actions/workflows/ci.yaml)

repository: dirien/gofish-bot

repo_name: dirien/gofish-bot


text:
---
templateKey: "blog-post"
blogKey: "Do you fancy a tour?"
description: "null"
publishedAt: "2016-09-04T11:23:00.000Z"
---
## The Past-Tameside

Those Harriers of more mature years will fondly remember the Tour of Tameside which ran from 1981 to 2000, before coming back for a final encore in 2003.

A fantastic event. 52 miles, 6 stages in 6 days, over varying terrains and distances around Tameside.

Brilliant camaraderie. You ran it as an individual and as part of a team of 4 over the week.

Part of the excitement was arriving at a different venue each night and checking the results board to see how far you and your team had climbed up the leader board.

The Tour was similar to the Tour de France but without a bike and without being in a foreign country.

Our very own Dave O’Leary and Neil Atherton are two of only four runners to have completed all of the Tours.

After 2003, due to cost and lack of sponsors the Tour came to an end.

## The Present – Merseyside

All of this was confined to the happy memory bank until 2013 when the Tour of Merseyside was born!

Exactly the same format as Tameside but taking place in Southport, Wirral, New Brighton, Everton and Hoylake in early July.

Devised by a chap who had run Tameside a number of times and was bowled over by the event as we all were.

Merseyside has gone from strength to strength. Starting with 100 runners, next year’s capacity entry of 400 sold out within one hour.

If you want to take part in the 2018 Tour make sure you sign up in quickly in July 2017.

## The Present – Rochdale

If you don’t fancy a full Tour how about a weekend Tour?

The Tour of Rochdale takes place in early June: Friday 6 miles road, Saturday 6 miles cross country and Sunday 6 miles fell.

Sounds easy ? This is hilly Rochdale, so it is a tough weekend and you know you have been in a race come Sunday lunchtime.

You always bump into a friend from the past whilst on Tour and this year it was good to see Hayley Kuter, once of our parish and winner of the South East Lancs League some years ago.

Hayley had a great weekend and was first lady in all three races.

## The Future – Tameside

Which brings us back to Tameside. Graham Jackson, also once of our parish, resurrected a mini Tour of Tameside a couple of years ago using some of the original Tour venues.

He started off with three races in three days but expanded it to four in four this year and the talk is of five in five for 2017.

Again it was good to see some faces from the past including Liam and Sue from Sweatshop who ran with us for a short while a couple of years ago. Liam has now formed his own running club in Widnes. The new Tour is doing well with the old Hyde 7 the highlight on the final day

## Your Future

So are you tempted? Tours are good fun. It’s good to battle the same people every night and see yourself climb (or not) the leader board.

It would be good to have some Harriers company and to enter a team or two in the Tours in 2017 .

Happy Touring!

— JP


text:
# Coding WebIDE

![](https://raw.githubusercontent.com/Coding/WebIDE/gh-pages/screenshots/import.png)

![](https://raw.githubusercontent.com/Coding/WebIDE/gh-pages/screenshots/workspace.png)

Coding WebIDE(https://ide.coding.net) is a cloud-based IDE developed by Coding Team.You can create your own workspace and develop projects here.WebIDE works fine with Git. You can use Coding、GitHub、BitBucket as your Git repository. Workspaces are powered by Docker Ubuntu containers.The development environment can be saved and shared to your team member.

[Live Demo](https://ide.coding.net/ws/?ownerName=duwan&projectName=WordPress&isTry=true)

Please submit issues to corresponding projects, that'll help us make issues tracking easier so that we can provide timely help to you. Submit frontend issues at [WebIDE-Frontend](https://github.com/Coding/WebIDE-Frontend/issues) and backend issues at [WebIDE-Backend](https://github.com/Coding/WebIDE-Backend/issues).

## Features

1. *Built-In Terminal*
2. *Syntax Highlighting*
3. *Language Tools*
4. *Themes*
5. *Split View*
6. *VIM／Emacs Mode*
7. *Previews*

[中文 README](https://github.com/Coding/WebIDE-Workspace/blob/master/README-zh.md)

This is the entry point to setup and run the WebIDE Community Edition project. It includes other 3 repos as git submodules.

## Modules

> [WebIDE-Frontend](https://github.com/Coding/WebIDE-Frontend) contains frontend code.
> [WebIDE-Frontend-Webjars](https://github.com/Coding/WebIDE-Frontend-Webjars) packs frontend to webjar.
> [WebIDE-Backend](https://github.com/Coding/WebIDE-Backend) contains backend code.

## How to clone

Clone this git repo to local. Then do:

```
git submodule init
git submodule update
```

This will also clone the other 3 repos via git submodule mechanism.

## Environment

WebIDE Frontend uses `npm` for package management, `webpack` and `babel` for building.
WebIDE Frontend Webjars & WebIDE Backend use `maven`.

Please ensure you have corresponding tools installed in your environment before build and run the project.

## Build and run

We provide a shell script `ide.sh` to ease the build and run process

> **./ide.sh build:** builds the frontend and packs to webjars
> **./ide.sh run:** start the backend and server

Server runs on port 8080 by default, visit localhost:8080 to check it out. Have fun!


text:
---
layout: post
title: "Develop Locally, Stage Nearby, Production Anywhere"
date: 2014-03-15 13:12:08 -0400
comments: true
categories:
---

One of the things that surprised me as I moved back into the land of corporate software is the number of developers I talk to that commute and work in offices **and yet develop on remote computers**. I thought, as you probably do, that by now *all* software development would be local, as in on the developer's own computer.

Instead, it is not uncommon for corporate developers to rely on remote shells or desktop virtualization to access remote development computers and use them to code. It's slow, unproductive, frustrating and so pre-1990's.

*Aside: Back then, remote development was the norm. Mainframes were too expensive to give to developers and most production platforms were not available in desktop form. You had to develop remotely.*

In this post, I want to point out how delusional remote development is in the 21st century and how local development can meet all Corporate needs.

## The Remote Development Delusion

There are several reasons given by Corporates for this old-school behavior, all of which are bogus.

> bo·gus ˈbōgəs/ adjective
> 1. not genuine or true; fake.

* **Security and Access Control**: The argument is that companies want to be sure that their developers do not run off with their source code, or that nothing is lost when computers get stolen or lost, that only authorized developers access the right parts of the code and that they can track who did what.

	Bogus because the average developer can still copy the code, or even rewrite it from scratch. Modern source code control systems and good network access control will resolve any security concern. Encrypted hard drives and startup passwords secure computers, even after theft.
* **Big or Sensitive Data**: The argument is that the amount of data processed by developers is huge, or the data itself is so sensitive, that they need to develop close to the data.

	Bogus because networks are plenty fast, developer databases do not need to be that huge and storage is cheap, so making local (or nearby) copies of data is simple. Bogus because sensitive data can be changed via scripts, or fake data generated.
* **Cost Savings**: The argument is that companies can share development resources such as licenses and installations and can therefore purchase cheaper computers for their developers.

	Bogus because the productivity losses in remote development by far outweigh the cost of a few measly licenses or computers. If a company cannot afford its development tools, it should not be using them. And developer tools these days are cheap or free, as are powerful computers, *and are licensed for local development*.
* **It's Policy**: The argument is that the company has a policy of remote development.

	*Bogus because the policy argument is always bogus*. Policies are made-up rules created by business people who generally know nothing about reality, or were written so long ago that no-one has cared to change them. Staff are forced to follow these bogus policies or be fired. It has nothing to do with right, productivity, cost or any other reality.

In each case, the argument put forward for remote development is bogus. Development on remote computers is slow, unproductive, subject to outages, and guaranteed to frustrate good developers and encourage them to leave.

## The Local Development Model

The local development model's mantra is simple, to:

> 1. Develop Locally
> 2. Stage Nearby
> 3. Production Anywhere

Developers code and compile on their own computers, using locally installed tools. All projects are staged (and continuously integrated) on servers nearby (as in the same office or on the same network). And then code can be deployed anywhere to run in production.

It's simple, local development makes sense and is the most productive way to develop.

* It's responsive, developers press a key and the response is instant.
* Developers can work anywhere, any time. Give a developer a laptop and they can work from home or at night.
* Developers can use their favorite tools and productivity enhancers to speed up development.
* Developers are only constrained by their own abilities, and not by the resources available on shared development machines, network flakiness or the slowness of remote operation.
* All development tools can and do run locally, and are designed  and licensed to do so. Local development is the *expected* model.

Staging nearby also makes sense.

* For large and complex code bases you can run continuous integration tools to build and report on errors far quicker than attempting production builds.
* You can use virtualization to spin up clean staging virtual machines on cheap retail hardware.
* If a developer does break something, it's close bye and easy to recover. And no other developers are affected.

Only production need be remote, and that can and usually is anywhere.

## Secure Local Development for Corporates

But corporates need their controls and security blankets. It turns out that the local development model can easily be made as secure and controlled as needed without punishing developers and throttling productivity.

Lets take each core remote development argument one at a time.

### Security and Access Control

Corporates want to be sure that the code and data is secure and only authorized personnel can access it. Easy:

* All modern computers and Operating Systems support encrypted hard drives. A password is needed to unlock the hard disk and yet another is needed to log in. A stolen encrypted hard drive is useless, and many systems can be remote wiped.
* All modern operating systems are built to keep folks out, and only to enable access by authorized users. Strong passwords are good enough, and even biometric access is available.
* If the data and access are secured, then communication needs to be as well. All systems come with built-in encrypted Virtual Private Networking to secure communications.
* Access to code can be controlled using an in-house hosted Source Code Control system. Developers can only see the projects that the company wants them to see, and the code is saved, logged, tracked and maintained in-house.

In short, no problem here.

### Big or Sensitive Data

Corporates argue that their data is too large, or is so sensitive that it needs to be tightly secured so development has to happen remotely. We've already covered securing code, the same applies to data, so what about data size? Well, assuming the developer needs access to *the whole* data set, easy:

* Modern hard drives are cheap and huge. And to be clear, there are exceptionally few corporate databases that cannot fit easily on a modern laptop drive. Big data is real, but rare. And even if the data is bigger than modern laptop drives, desktops with lots of drive bays or even SAN's are ridiculously cheap.
* If data is too sensitive, run a script on a copy of the database to remove or change sensitive information. For example, replace all credit card numbers with fake ones. Or use scripts to generate accurate yet fake data for developers. There are lots of tools out there to help do this.
* If the data is stored in a commercial database product, and the company is so cheap it does not buy licenses for developers, then maybe they cannot run it locally. Fine, but modern networks are fast, and running a one additional license as a development database server nearby, close to staging, accessible via VPN, is cheap.
* And if the company really wants to be tight, it can create and clone secure virtual machines that developers can spin up and run whenever they need data access.

It is rare that a developer needs access to the entirety of a database, and even rarer that the data does not fit on a local disk. Big data is not a problem. And there are solutions to sensitive data, so that too is not a problem.

### Cost Savings

But what about the cost of all these powerful laptops, tool licenses and staging servers? I could point out that maintaining development servers, licensing and the infrastructure to support remote development is just as high cost (oh, I just did). But:

* Computers are cheap, ridiculously so. And for the price you get lots of fast cores, oodles of RAM and massive hard disks. People and people's time is expensive. What would you rather spend money on?
* Modern development tools assume local development and so license terms and conditions expect this. The cost of giving each developer a licensed copy vs running a the same licensing centrally is exactly the same.
* And then there is the free and open source option. Instead of using expensive proprietary tools, try using open source languages that all the cool companies are using. The cost of getting support on Open Source is negligible and the products are being used by millions.

Choosing between needing more expensive developers using cheaper computers versus having fewer, more productive ones is easy when you look at the cost. Local development is cheaper.

### Policies

And then there is the legacy of policy. A business that is too rigid to change in the face of changing technologies, costs and realities has no right to survive. A business that is constrained by policy cannot evolve.

If a company wants to hang on to their developers, and get development done quicker and better, local development is the way to go. And if the only thing that's holding the company back is a few silly written rules, er policies, *burn them*.

## Develop Locally, Stage Nearby, Production Anywhere

Back in the 1970's, 1980's and early 1990's, remote development was the norm. Because it had to be. Mainframes and server platforms were expensive and unavailable on desktops. Computers were not secure and networks were unavailable or slow. And the tools were designed for this model.

The downsides were the same as modern remote development: key press delays, slowdowns as other users took too many resources, layers of security and technology needed to enable remote access and all sorts of flakiness and problems. The upside, well, it was the only way to develop.

But since then we've moved on. A computer on every desk (and now lap and pocket) is the norm. Servers and server platforms can run on laptops as well as on big iron in production. Computers are secure and fast, encrypted networking is ubiquitous.

There is no downside to local development. The last 20 years have been spent making local development a reality. The upside is huge. Faster, anytime, anywhere, productive developers result.

There is no downside to nearby (or even local) staging. The upside is also huge. Better, faster builds, quicker identification of issues, and better testing all result.

Welcome to the 21st century. **Develop Locally, Stage Nearby, Production Anywhere.** Remote development's time has passed.

*Follow the author as [@hiltmon](https://twitter.com/hiltmon) on Twitter and [@hiltmon](http://alpha.app.net/hiltmon) on App.Net. Mute `#xpost` on one.*

extension: markdown


text:
---
title: Roast Lemon Chicken
author: lbjay
layout: post
permalink: /2008/01/28/roast-lemon-chicken/
categories:
  - CSA
  - Recipes
---

This is a really simple recipe that’s help me recently get over the intimidation factor of working with whole chickens. I’ve done this twice now; once with a kosher bird from Empire and more recently with a whole chicken from my January Meat CSA share. I’ll let you guess which one was tastier.

What you need:

  * 2 T butter
  * 3-4 garlic cloves, peeled
  * 1 whole lemon
  * 1 sprig fresh rosemary
  * 1 whole chicken, 3-4 lbs.
  * 1 cup chicken broth, white wine, water or combination of any

Preheat the oven to 375.

Rub the bird inside and out with some salt & pepper. Cut the lemon into eighths. Stuff the lemon, garlic and rosemary into the cavity. Use a couple of toothpicks to secure the skin flaps over the cavity; this serves to keep the stuff from falling out when you turn the bird later.

Set the bird breast-side down in a well-oiled v-rack inside a roasting pan. Brush the top with 1 tablespoon of melted butter.
Roast for 40 minutes. Take the bird out and flip it so it’s breast-side up (I use wads of paper towels in either hand to grab it). Add the broth/wine/water to the roasting pan. Back in the oven and roast “until done”, about 45-50 minutes.

Note that the roasting time is going to depend on several things: size of the bird, your oven, etc. I’ve got a convection roast setting that probably reduces the time for me. When in doubt use a meat thermometer.

You can make a sauce with the pan drippings but I’ve been saving mine to make a chicken soup later in the week.

**Bonus**: here’s a video showing how to carve your yummy, roasted chicken.

<embed src="http://www.youtube.com/v/4mYf-QqaecQ&rel=1" type="application/x-shockwave-flash" wmode="transparent" height="355" width="425">
</embed>


text:
##  WEB ARCHITECTURE
- https://engineering.videoblocks.com/web-architecture-101-a3224e126947
- https://arcentry.com/blog/scaling-webapps-for-newbs-and-non-techies/
- https://github.com/binhnguyennus/awesome-scalability

## TOOLS
- https://crontab.guru/
- https://cronitor.io/index
- https://certbot.eff.org/
- https://jmeter.apache.org/

## VIM

- https://www.fprintf.net/vimCheatSheet.html

## SERVICES
- https://vercel.com/
- https://www.netlify.com/
- https://www.checklyhq.com/

## KUBERNETES
- https://github.com/cloudmelon/melonkube

## DOCKER
- https://github.com/veggiemonk/awesome-docker
- https://dev.to/softchris/5-part-docker-series-beginner-to-master-3m1b

## VAGRANT
sudo vagrant up				>> ensure that .vagrant/machines/default/virtualbox/creator_uid is 0
sudo vagrant halt
sudo vagrant ssh
sudo yum -y install phpmyadmin
mysql -u root example -- just test
ifconfig (add IP ADRESS <IP_ADDRESS> + remote DENY )
sudo vim /etc/httpd/conf.d/phpMyAdmin.conf			>> KEYS: INSERT +  CTRL C + :w + :q
sudo service httpd restart

vim /etc/phpMyAdmin/config.inc.php
$cfg['Servers'][$i]['AllowNoPassword'] = TRUE;
+ MODIFY USER : root + secret

http://<IP_ADDRESS>/phpmyadmin
root secret
exit

## CRON

crontab -e

Once you enter the above command you will be asked to choose a text editor. Choose nano if you are first time editing or go with your choice.

In the crontab, the m h dom mon dow user header has the following meaning

* m = The minute when the cron job will run. (0 to 59)
* h = A integer determining the hour when the tasks will run. (0 to 23)
* dom = Day of the Month when the cron job will run. (1 to 31).
* mon = The month when the cron job will run. (1 to 12)
* dow = Day of the Week from 0-6 with Sunday at 0. (0 to 6)
* user = The User under which the cron will run.
* command = The Linux command you wish to execute.

## DOMAIN CHECK

nslookup
set type=TXT
domain.fr

## PROCESS + UTIL

PUTTY

## SUPERVISION
htop

## UPDATE
aptitude update
aptitude upgrade

## UPDATE DATE
aptitude install ntp ntpdate
sudo nano /etc/ntp.conf

server 0.fr.pool.ntp.org
server 1.fr.pool.ntp.org
server 2.fr.pool.ntp.org
server 3.fr.pool.ntp.org

service ntp start

## FIREWALLING
iptable

vps1 et vps2  		> entree  22 pour tout le monde . et 80 si origin load balancer
sql					> entree  3389 depuis vps. et le 22 tout le monde

## DOCKER
play-with-docker.com
https://github.com/JeremyLikness/usda-microservice
https://dzone.com/articles/build-and-deploy-a-mongodb-angular-nodejs-app-usin


text:
---
title: "Apache Settings"
aliases:
  - /en/master/advanced/web-configuration-overrides/
---

The following settings files in the project codebase can be used to override default Apache settings.

Use `.docksal/etc/apache/httpd-vhost-overrides.conf` to override the default virtual host configuration:

```apacheconfig
DirectoryIndex index2.html
```

Use `.docksal/etc/apache/httpd-vhosts.conf` to define additional virtual hosts:

```apacheconfig
<VirtualHost *:80>
	ServerName docs.test.docksal

	ProxyPass / http://docs.docksal.io/
	ProxyPassReverse / http://docs.docksal.io/
</VirtualHost>
```

## Using Different Apache Versions {#apache-versions}

When using the default stack (a custom project stack is not defined in `.docksal/docksal.yml`), switching can be done
via the `WEB_IMAGE` variable in `.docksal/docksal.env`, e.g.:

```bash
WEB_IMAGE='docksal/web:2.1-apache2.2'
```
This can also be set with `fin config set`.
```bash
fin config set WEB_IMAGE='docksal/web:2.1-apache2.2'
```
Remember to run `fin project start` (`fin p start`) to apply the configuration.

Available images:

- Apache 2.2 - `docksal/web:2.1-apache2.2`
- Apache 2.4 - `docksal/web:2.1-apache2.4` (default)

There are also "edge" versions available that contain code from ongoing updates, but may not be stable. Don't switch to an
edge image unless directed to do so by the Docksal team for testing purposes only.

See documentation for projects using a [custom stack configuration](/stack/custom-configuration/).

repository: sergiuteaca/docksal

repo_name: sergiuteaca/docksal


text:
# E011-CamHolder - 11th whoop
EF-02 AIO Camera support for the EAchine E011 to be 3D printed

The E011 can be converted into the cheapest FPV system with good flying performances, the Inductrix & the E010 are well known platform to do cheap FPV but these are very underpowered & requires a lot of mods for these to be good platforms. the E011 is a new quad that is slightly larger than the E010 but much more powerful because it is made to cary a figurine.

the camera angle is set to 15 degrees.

support for small camera for the Banggood: Eachine E011 Quadcopter

all in one VTX Banggood: EAchine EF-02 AIO FPV VTX 800TVL 5.8G 25mW for E010c (Better, cheaper &Lighter)

The best thing is that you ca flash it with accro firmware:

The Open source firmware for the E011 Github: Silver13/Eachine-E011
a Video tutorial on Youtube YouTube Tuto
An online tutorial to flash the drone Silverware tuto
Flashing instructions: RCgroup tuto

Designed with OpenScad in the Fablab Artilect in Toulouse


text:
# Kubernetes Checklist

---

Introduction

>

Coverage

>

---

##

Explain what is kubectl, and its relationship with

Red Hat Definition: "A Kubernetes cluster is a set of node machines for running containerized applications. If you’re running Kubernetes, you’re running a cluster.

Read more [here](https://www.redhat.com/en/topics/containers/what-is-a-kubernetes-cluster)


text:
---
title: L.L.Bean Responsive Email
layout: default
modal-id: 13
date: 2020-06-05
thumbnail: LLB_email.png
alt: L.L.Bean responsive email
client: L.L.Bean
category: LLB
description: Redesign of L.L.Bean's transactional emails to make them responsive.
tasks: Responsive Email Design, Interaction Design, Collaboration with Visual Designers, Prototyping
deliverables: Wireframes, Responsive Prototype

---
### Problem
Users viewing L.L.Bean transactional emails on their phones had a difficult time reading the contents of the email.

### Process
![Image showing process ](./img/portfolio/LLB/Email/LLBResponsiveEmailProcess.jpg)
### Solution
* Responsified existing emails and incorporated new business requirements related to matching transactional emails to the llbean.com order summary screen.

### Transactional Email Screens
#### Mobile
![Image showing a transactional email on mobile.](./img/portfolio/LLB/Email/trans-mobile.png)
#### Desktop
![Image showing a transactional email on desktop.](./img/portfolio/LLB/Email/trans-desktop.png)

repository: shannonmcharg/portfolio

branch_name: refs/heads/gh-pages

repo_name: shannonmcharg/portfolio


text:
# playlist-downloader

A python program that uses the Spotify Web API to download a user's public playlist metadata as JSON.

# Usage

Before using this program, you must first obtain a Spotify API client id and secret.
You can do so by following the instructions [here](https://developer.spotify.com/web-api/tutorial/#registering-your-application).

Once you have obtained your client id and secret, create a file named "config.json" in the project directory and enter your "client_id" and "secret" as values in JSON notation. The "sample-config.json" is an example of how to properly do this.

Now install the program's dependencies with `pip` by running `pip install -r requirements.txt` in the project directory.

You can now run the program using `python playlist-downloader.py <username>`

## Options and usage explanations

```
python playlist-downloader.py <username>
```
will list all of <username>'s public playlists and allow you to pick one to download.

```
python playlist-downloader.py <username> -l
```
will do the same thing, but without the line saying you missed adding a playlist name

If you know the name of the playlist you want to download, you can do so with:
```
python playlist-downloader.py <username> -p <playlist-name>
```

# Issues

If you have any issues with usage, or would like additional features added, please let me know by reporting it here on GitHub.

# Licensing

This software is licensed under the MIT License, so do with it what you will. :)

repository: damon-myers/spotify-playlist-downloader

repo_name: damon-myers/spotify-playlist-downloader


text:
# User manual

You move the Oil Barrel using the ASWD keys and the Flower sack using the arrow keys.

Move around the board trying to cover a much as possible with oil stains or flowers respectively.

As the Oil Barrel you have to reach the oil tower to get more oil and as the Flower sack you have to move to the Wheelbarrow to get more flowerseeds.

Change gamespeed using 1 (slowest) to 5 (fastest), 3 being default speed.

When finished, restart the game by pressing ENTER.

Easy ! Except that your opponent has the same goal.

license: MS-PL

repository: Jeern/Klimakonflikt

repo_name: Jeern/Klimakonflikt


text:
# Quickstart

_This documentation is WIP_

To get started quick with Mutant use `mutant-starter-pack` a _mostly_ sane
collection of Mutant modules. Once you are in no rush you can pick and choose
the modules you _really_ need.

We will now make a quick overview of modules included in `mutant-starter-pack`.

Remember to add `mutant-starter-pack` dependency in your build system of choice.
In case you are using `gradle` add:

` gradle placeholder `

#### Your first Mutant application

```kotlin
import org.droba.mutantStarterPack.mutant

fun main (args : Array<String>) {
  mutant {
    get("/") { "Hello World!" }
  }
}
```

Visit `localhost:8080` and you should be greeted with `Hello World!`

See [Mutant builder]() docs for more information.

#### Routes

We can register routes inside `mutant { }` by using `get`, `post`, `put`, `delete`, `patch`, `head`, `options` and `trace`
functions:
```kotlin
//verb    path   action

  get     ("/") { "fetch"  }
  post    ("/") { "create" }
  put     ("/") { "update" }
  delete  ("/") { "delete" }
  patch   ("/") { "patch"  }
```

See [Routing]() docs for more information.

#### Request info

You can access request information trough the `req` prop.
Let's read and display the `User-Agent` header from the request:

```kotlin
  get ("/user-agent") {
    req.headers["User-Agent"]
  }
```
Visit `localhost:8080/user-agent` and you should see your user agent string!

Some of the info you can get from `req`:
```kotlin
  req.params      // get url params  ( ?id=slimyJelly )
  req.pathParams  // get path params ( /creature/undeadJelly )
  req.formParams  // get form params ( x-www-form-urlencoded )
  req.body        // get req body
  req.headers     // get req headers
  req.cookies     // get cookies
  req.session     // get session
```
See [MutantRequest]() docs for more information.

#### Working with JSON

`mutant-starter-pack` uses `mutant-gson-json-renderer` for easy json serialization
and deserialization.
Let's write a route that reads json content from request body and returns json:
```kotlin
  data class User(val name: String, val surname: String)

  get ("/json") {
    val user = req into User::class  // deserialize into User
    json(user)                       // emit User as json
  }

  // there is also an alternate way to achieve the same result
  get ("/json_alt") {
    val user = req.into<User>()     // deserialize into User
    json(user)                      // emit User as json
  }
```

If you need to quickly construct a json object:
```kotlin
  get ("/json2") {
    jsonObject(
    	"name"    to "Rick",
        "surname" to "Sanchez"
    )
  }
```
This would return a json object `{ name : "Rick", surname : "Sanchez" }`

See [mutant-gson-json-renderer]() docs for more information.

#### Rendering views

##### Rendering views with kotlinx.html

You can use [`kotlinx.html`](https://github.com/Kotlin/kotlinx.html) to write your views in Kotlin!
`kotlinx.html` is a Kotlin DSL for building HTML.
You can check out how such views are organized in [`mutant-abominable-pasture`](https://github.com/statikowsky/mutant/tree/master/mutant-abominable-pasture) example project.

##### Rendering views with handlebars

`mutant-starter-pack` uses `mutant-handlebars-template-renderer` mutant module for template rendering.
This renderer uses `handlebars.java` for template rendering. This module expects your template files to be located
in the root of your project inside `/templates` directory.

Let's create `user.hbs` template to our `/templates` directory:
```handlebars
   <div>
     <h1>Hello there {{this}}</h1>
   </div>
```

And now let's render our view:
```kotlin
   get ("/user") {
     view("user", "Rick Sanchez")
   }
```
If you now visit `localhost:8080/user` you should see `Hello there Rick Sanchez`!

See [mutant-handlebars-template-renderer]() docs for more information.

#### Organizing controllers and controller discovery

##### Organizing controllers manually

Instead of writing your actions when defining you routes e.g.
```kotlin
   get ("/controllerOrg") { "Let's organize!" }
```

You can create separate classes or objects that will hold your actions
and then bind them to your routes:

`controllers/UserController.kt`
```kotlin
   object UserController {
     val get     : Action = { "Sry no users here yet!" }
     val create  : Action = { "Nothing to update yet!" }
     val summary : Action = { "Nothing to do here :(!" }
   }
```

Note that the lambdas are of type `Action`. `Action` is a typealias for `M.() -> Any`.

You can then reference your actions in Mutant setup:
`AppStart.kt`
```kotlin
   mutant {
     get(  "/user/:id",     UserController::get)
     post( "/user",         UserController::create)
     get(  "/user/summary", UserController::summary)
   }
```

##### Using controller discovery

If you are ok with abiding with a few conventions you can use `ControllerDiscovery` from `mutant-controller-discovery` module.
It is provided by default in `mutant-starter-pack`. It allows us to write and wire up controllers
easily.
To enable controller discovery in your project you need to call `DiscoverControllers()`
in mutant setup:

`AppStart.kt`
```kotlin
   mutant {
     discoverControllers()
   }
```

`controllers/UserController.kt`
```kotlin
   object UserController {
     // default routes
     //
     // get will map to GET `/user/:id`
     // create will map to POST `/user`

     val get    : Action = act { "Sry no users here yet!" }
     val create : Action = act { "Nothing to update yet!" }

     // non-default routes need to be annotated with http methods

     @Get val summary : Action = { "Nothing to do here :(!" }

     // all non-default routes get automatic paths from field name,
     // use @Path annotation to override

     @Get @Path("/dancers")
     val listDancers : Action = { userService.dancers }

     // use a lambda with an M receiver and parameters that represent the
     // values you need in your request
     //
     // in this example you path param `:shirt` would be bound to `shirt`
     // and request body would be bound to `detailsDto`
     //
     // check controller discovery docs for more info

     @Post @Path("/details/:shirt/nonsensical/")
     val nonsensical M.(String, DetailsDto) -> Any = {
     	shirt, detailsDto -> "What are you doing?"
     }
   }
```

See [mutant-controller-discovery]() docs for more information.

#### Database

`mutant-starter-pack` includes multiple db related packages:
 - `mutant-hikari-cp` (database pool)
 - `mutant-jooq` (typesafe SQL dsl api)
 - `mutant-flyway` (migrations)

repository: statikowsky/mutant

repo_name: statikowsky/mutant


text:
---
title: FAQ
keywords: FAQ
last_updated: March 15, 2021
summary:
sidebar: mydoc_sidebar
permalink: faq.html
folder: landing
toc: false
list_images: '/assets/images/illustrations/draculi_1080.jpg,/assets/images/illustrations/laurence_the_duelist_1080.jpg,/assets/images/illustrations/iscara_the_ten_thousand_guns_1080.jpg,/assets/images/illustrations/alpha_draculi_1080.jpg'
---

## Am I locked in if I decide to use Novellia?

No. You select what features are beneficial for your product.

## Is this a proposal for a platform or a game?

Yes.

We are building the video game Occulta Novellia in order to help test the systems needed to build the Novellia Platform.

## What is the Novellia Platform?

The platform is a set of tools designed for video games to interact with the Cardano blockchain. The Novellia Dashboard acts as a decentralized game store. The tools provided allow developers to pick and choose blockchain features to use in their video game.

These tools, while optional, provide a formally reviewed standard that ensures certain design provision are met, including that assets within Novellia are hard to devalue by design.

Our process:
1. Plan
2. Review
3. Rework
4. Follow-up
5. Keep iterating

If it isn't finished, it isn't shipped.

## What is Occulta Novellia?

It's a surreal horror turn-based strategy monster fighting game. You will be able to fight through single player story lines, giving you a better understanding of the multiverse, or fight in decentralized peer-to-peer battles, with rewards going to the victor.

## I don't get it? Why do we need the Occulta Novellia video game?

Because designing a platform is hard.

It's more difficult when there's nothing to test against. We could wait until it's finished, but then it'd be too late. Occulta Novellia efficiently forces us to ensure the platform conforms to real-life scenarios, not an ideal.

## What is Novellia if it's not just a dashboard?

The Novellia platform exposes a decentralized autonomous organization (DAO) where holders of the Novellia (NVLA) token vote to determine what's allowed into the Novellia Dashboard.

The dashboard is just a UI that surfaces everything that's been registered on the DAO, allowing it to be interacted with all in one place.

## How do I get my game on Novellia?

Registration on the DAO involves:
1. Filling out a middleware that is proposed to the DAO.
2. If the proposal passes, the middleware is registered.
3. This is the developer's "personal space" on the DAO.
    - They are free to modify the data within some reasonable restrictions.

That's it.

## So I'm going to make $0 off my game because people will buy used only?

If you want to.

Otherwise, you could create multiple game license kinds. Perhaps there's a 10% chance that a buyer will get a special game license unlocking an extra skin, level, or something else.

## How do I make blockchain assets for my game?

We provide minter standards for:
- Native Tokens
- NFTs
- Semi-fungible Tokens

These can be modified at will. The value is in the design behind the standard. When your team is ready to mint assets, they don't need to do any research.

By following our standard, assets can be included in the Novellia Marketplace, provided in the Novellia Dashboard. This happens automatically.

## How do I see my blockchain assets?

The Novellia Dashboard exposes a read-only wallet interface which allows highly unique tokens such as NFTs to be displayed without a loss of information.

For NFTs like trading cards, information such as artwork, skills, gameplay, won't appear in any typical wallet. Our interface is extensible with plugins so anyone can get a first-class view of their holdings.

## Can I trade within the Novellia platform?

Yes.

The Novellia Dashboard contains a decentralized marketplace that allows users to purchase new assets from conformant minting contracts, or trade those same assets on a resale market.

## Is this totally decentralized and non-custodial?

Yes.

All data required for the dashboard's functioning is enumerated from the Cardano blockchain.

We are non-custodial. Connect your wallet using a plugin similar to MetaMask.

Hardware Wallet / Software Wallet → Integration Layer → Accessed safely by game

## Why do we need a DAO? Why do projects need to voted on?

The DAO helps filter out low quality content (buggy, inappropriate, scams) without requiring a centralized authority. This means that content cannot be censored.

## What game engines are supported?

We'll begin by implementing an engine agnostic set of tools, followed by specific integrations for whatever is most in demand.

## Why do I want my game to be on Novellia?

We provide a low-fee ecosystem to help you hit the ground running.

- Marketplace
  - Very low fees. Avoid those +20% app store fees!
  - Earn commissions on resale markets for blockchain assets.
- Open source software (for critical plugins. the dashboard will begin as closed-source)
  - Fix it yourself if you need it now.
  - Read the code and you can know there's no backdoors.
- Decentralization
  - Your game can't be censored for being too scary or for arbitrary political reasons.
- Identity
  - Users know they aren't buying copy-cat blockchain assets because they're purchasable directly within Novellia.

## Are we a scam?

No. This is a scam [Useless Ethereum Token](https://uetoken.com/).

branch_name: refs/heads/main


text:
## Sample application

This application demonstrates the use of the vertx-aws-lambda adapter.

You can build this application by issuing:

> mvn package

The sample application jar file *vertx-aws-lambda-sample-app-0.0.1-SNAPSHOT.jar* can be directly uploaded as a function package to AWS Lambda. It was tested with 256 MB of memory and the timeout set to 60 seconds.

repository: outofcoffee/vertx-aws-lambda

repo_name: outofcoffee/vertx-aws-lambda


text:
## OSPRay disabled on older x86\_64 processors

OSPRay's ISPC backend requires SSE4.1 to work (it calls `abort()` if not
supported), so avoiding the crash on such old hardware (SSE4.1 is from 2006 in
the Core 2 line) is of more interest than potentially working with OptiX (which
is now hidden due to this check).

repository: johndam/VTK

repo_name: johndam/VTK


text:
# [How To Use Events in Node.js The Right Way](https://medium.freecodecamp.org/using-events-in-node-js-the-right-way-fc50c060f23b)

* Before event-driven architecture, in order to communicate between different parts of an application, one would simply invoke the requisite method
* However, this causes coupling between these two parts of the application - by using an event-driven architecture (i.e an Observer pattern), there is less coupling
* This loose coupling can lead to increased complexity
  * It can make it harder to keep track of dependencies
  * It's particularly prone to issues when events are emitted from listeners
* Consider firing an event only when a unit of business logic finishes execution
  * For example, a user's registration might involve many different steps but from a business stand point, it's one step
  * If we want to send emails after a user's registration, it might make sense to use an event-driven approach where we fire an event when registration finishes and then we have listeners for this event that send out these emails
* Node's event architecture has objects called "emitters" (specifically, an `EventEmitter` class)
  * The emitters and the listeners should be separated - these listeners can be reused (i.e. for both of these events, send the same kind of email)
  * When multiple listeners are attached to a single event, they will be executed synchronously and in the order that they were attached

```javascript
const EventEmitter = require('events');

// Instantiate an emitter
const emitter = new EventEmitter();

// In some business logic, emit some event with a name, and some payload associated with the event
emitter.emit('some-event', payload);

// In another module, have a listener that does something with the payload
emitter.on('some-event', (payload) => {
  // Do something with the payload
});
```

* A listener should do one thing and do it well
* Avoid writing too many conditionals within a listener that decide what to do depending on the data (message) that was transmitted by the event
* If find using the payload to decide what to do, simply use a different event type
* Listeners need to be detached explicitly if it's part of an object (like a method) because if not, the object will never be GCed since a part of the object (listener) will continue to be referenced by the emitter
* So in a chat app, if we have a "new message" event listener referenced in a `ChatUser` class, if a user goes offline, we need to make sure to call `removeListener` for the "new message" event

repository: jaebradley/notes

repo_name: jaebradley/notes


text:
# streamlink

> Put video from various services into a video player of your choice.

- Quickly streamlink to your default player:

`streamlink {{link}}`

- Streamlink with the highest/lowest quality:

`streamlink {{link}} {{best/worst}}`

- Let the player control the transport of the stream:

`streamlink {{link}} --player-passthrough={{hls/http/trmp}}`

- Write stream data to FILENAME instead of playing it:

`streamlink {{link}} -o={{filename}}`

repository: nobuhibiki/tldr

repo_name: nobuhibiki/tldr


text:
---
title: "getHardware"
description: "Retrieve an account's associated hardware objects."
layout: "method"
tags:
    - "method"
    - "sldn"
    - "Brand"
classes:
    - "SoftLayer_Brand"
aliases:
    - "/reference/services/softlayer_brand/getHardware"
---
# [SoftLayer_Brand](/reference/services/SoftLayer_Brand)::getHardware

Retrieve an account's associated hardware objects.

## Overview
Retrieve an account's associated hardware objects.

-----

### Parameters
|Name | Type | Description |
| --- | --- | --- |

### Required Headers
* SoftLayer_BrandInitParameters
* authenticate

### Optional Headers
* SoftLayer_BrandObjectMask
* SoftLayer_BrandObjectFilter
* resultLimit
* SoftLayer_ObjectMask

### Return Values
* <a href='/reference/datatypes/SoftLayer_Hardware'>SoftLayer_Hardware[] </a>

gha_language: HTML


text:
---
title: "Hyperdiet"
author: glennji
date: 2019-05-16T20:47:37+10:00
draft: false
type: note
crosslink: "true"
---
After four decades on this planet, two of which I've been solely responsible for choosing what to eat, I still don't know exactly what to feed myself for the best outcomes: athletic performance, appropriate weight, sleep, digestion and cognitive function. Why is this so hard, for me and so many others?
This is my next experiment:

1. Reduce animal protein (and read up on veganism)
2. Skip dairy, especially anything with lactose in it
3. No added sugar
4. Increase leafy greens
5. Intermittent Fasting (OMAD)

## Hacking nutrition

e.g.

* Four Hour Body
* PAGG
* Cissus Quadrangularis

Research:

* creatine
* glutamine
* essential fatty acids (EFAs)
* alpha-lipids

Books:

* How To Eat *(Mark Bittman & David Katz)*
* The Warrior Diet

repository: glennji/website

repo_name: glennji/website


text:
## Get started

### Prerequisites

- Make sure your local `go.mod` declares `go 1.18`
- Go 1.18 not being relaesed yet, I suggest using the wrapper [gotip](https://pkg.go.dev/golang.org/dl/gotip):
  > The gotip command compiles and runs the go command from the development tree.

### Installation

Assuming the above prerequisites are fulfilled:

```sh
gotip get github.com/drykit-go/slices
```

## Available functions

- `Map`
- `Filter`
- `Reduce`
- `Apply`
- `ApplyUntil`
- `KeysOf`
- `ValuesOf`

## Examples

See [unit tests](./slices_test.go) for some usage examples.

repository: drykit-go/slices

repo_name: drykit-go/slices


text:
---
title: nrpClassic
excerpt: nrp-classic next release problem data
layout: repo-dataset
author: Jifeng Xuan
---

# URL

  * [Data Link (DOI)](https://doi.org/10.5281/zenodo.268460)

# Change Log

When | What
---- | ----
   November 16, 2011 | Donated by [Jifeng Xuan](/repo/people/data-donors/promise3.html)

This is one of the next release problem (NRP) data sets donated by [Jifeng Xuan](/repo/people/data-donors/promise3.html).
More notes on NRP can be found [here](http://oscar-lab.org/people/~jxuan/page/project/nrp/).

# Reference

Jifeng Xuan, He Jiang, Zhilei Ren, Zhongxuan Luo, "[Solving the Large Scale Next Release Problem with a Backbone Based Multilevel Algorithm](http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=6261327)", IEEE Transactions on Software Engineering, vol. 99, no. PrePrints, , 2011


text:
# Jsup
[![Build Status](https://travis-ci.org/wizardone/jsup.svg?branch=master)](https://travis-ci.org/wizardone/jsup)
[![codecov](https://codecov.io/gh/wizardone/jsup/branch/master/graph/badge.svg)](https://codecov.io/gh/wizardone/jsup)

Jsup produces json using oj. It is really fast, simple and reliable. If
speed is what you are looking for in your APIs then you should check it
out.
If you have a complex architecture you should probably check gems like
`roar`, `jbuilder`, `serializers` etc.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'jsup'
```

And then execute:

`bundle`

Or install it yourself as:

`gem install jsup`

## Usage
```ruby
user = User.first
Jsup.produce do |j|
  j.name user.name
  j.email user.email
end
```
Will produce:
```json
{
  "name": "John",
  "email"<EMAIL_ADDRESS>}
```

```ruby
Jsup.produce do |j|
  j.name 'Stefan'
  j.fetch(@address, :city)
end
```
Will produce:
```json
{
  "name": "Stefan",
  "city": "Sofia"
}
```
You can fetch multiple attributes:
```ruby
j.fetch(@address, :city, :zip_code, :street)
```

You can also produce nested content:
```ruby
Jsup.produce do |j|
  j.name 'Stefan'
  j.address do |ja|
    ja.street '13 march'
    ja.city 'Sofia'
  end
end
```
Will produce:
```json
{
  "name": "Stefan",
  "address":
    {
      "street": "13 march",
      "city": "Sofia"
    }
}
```
If you want to extract from a hash it is also possible:
```ruby
Jsup.produce do |j|
  j.fetch({first: 'my', last: 'initial'}, :first, :last)
end
```
```json
{
  "first": "my",
  "last": "initial"
}
```

## Benchmarking
For rather simple data structures jsup is way faster than jbuilder:
```ruby
def jb
  Jbuilder.encode do |person|
    person.name 'Stefan'
    person.email<EMAIL_ADDRESS>    person.address 'some'
  end
end

def js
  Jsup.produce do |person|
    person.name 'Stefan'
    person.email<EMAIL_ADDRESS>    person.address 'some'
  end
end

Benchmark.bm do |x|
  x.report('jbuilder') { 10000.times { jb } }
  x.report('jsup') { 10000.times { js } }
end
```
Results:
```shell
user     system      total        real
jbuilder  0.110000   0.000000   0.110000 (  0.112200)
jsup  0.030000   0.000000   0.030000 (  0.025732)
```

### I am welcoming ideas about new features and options for jsup! If you have any, let me know!

## Development

  After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

  To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

  Bug reports and pull requests are welcome on GitHub at https://github.com/wizardone/jsup. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

  The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

repository: wizardone/jsup

repo_name: wizardone/jsup


text:
# Module hexagon_core

This module holds utilities used in other libraries of the toolkit. Check the packages'
documentation for more details. You can find a quick recap of the main features in the sections
below.

### Install the Dependency

This module is not meant to be imported directly. It will be included by using any other part of the
toolkit. However, if you only want to use the utilities, logging or dependency injection (i.e.: for
a desktop application), you can import it with the following code:

=== "build.gradle"

    ```groovy
    repositories {
        mavenCentral()
    }

    implementation("com.hexagonkt:hexagon_core:$hexagonVersion")
    ```

=== "pom.xml"

    ```xml
    <dependency>
      <groupId>com.hexagonkt</groupId>
      <artifactId>hexagon_core</artifactId>
      <version>$hexagonVersion</version>
    </dependency>
    ```

### Logger

The following code block shows the most common use cases for the [Logger] class:

@code hexagon_core/src/test/kotlin/HexagonCoreSamplesTest.kt:logger

By default, Hexagon uses the [Java Util Logging] logging library, you can use any of its
implementations by just adding another logging adapter as a dependency. Below you can see some
alternatives:

* [Logback](/logging_logback)
* [SLF4J JUL](/logging_slf4j_jul)

TODO Add `LoggingManager` examples for changing logging level

[Logger]: com.hexagonkt.logging/-logger/index.md
[Java Util Logging]:
  https://docs.oracle.com/javase/8/docs/api/java/util/logging/package-summary.html

### Dependency injection

You can take advantage of dependency injection using the [InjectionManager] object.

The implementation is a map of classes (with an optional tag) to provider functions (in essence:
`Map<KClass<*>, () -> Any>`). It is a very simple, yet complete, DI implementation.

You can bind supplier functions or objects to classes. If a class is already bound, later calls to
`bind*` methods are ignored. However, you can use the `forceBind*` methods if you need to override
a binding (in tests for example).

Check this sample to bind constructor functions or objects to classes, and inject them later:

@code hexagon_core/src/test/kotlin/HexagonCoreSamplesTest.kt:injectionUsage

!!! Info
    Dependency Injection is not required by the toolkit. All classes and methods have versions
    receiving all of their dependencies, so you can use them instead relying on injection (or use
    another DI library of your choice).

[InjectionManager]: com.hexagonkt.injection/-injection-manager/index.md

### Serialization

The core module has utilities to serialize/parse data classes to JSON and YAML. Read the following
snippet for details:

@code hexagon_core/src/test/kotlin/HexagonCoreSamplesTest.kt:serializationUsage

# Package com.hexagonkt.helpers

JVM information, a logger class and other useful utilities.

# Package com.hexagonkt.injection

Utilities to bind classes to creation closures or instances, and inject instances of those classes
later.

# Package com.hexagonkt.logging

Provides a logging management capabilities abstracting the application from logging libraries.

# Package com.hexagonkt.serialization

Parse/serialize data in different formats to class instances.

repository: BikramjeetSingh/hexagon

repo_name: BikramjeetSingh/hexagon


text:
# Employee Management System

A command line application Content Management Systems (CMS) for managing a company's employees. Gives the ability to view and manage the departments, roles, and employees.
![License Badge](https://img.shields.io/github/license/meredithcoyne/employee-management-system)

A command line application Content Management Systems for managing a company's employees where it can view and manage the departments, roles, and employees.

## Table of Contents
------
 * [Installation](https://github.com/meredithcoyne/employee_tracker#Installation)
 * [Usage](https://github.com/meredithcoyne/employee_trackerhttps://github.com/meredithcoyne/employee_tracker#Usage)
 * [Resources](https://github.com/meredithcoyne/employee_tracker#Resources)
 * [Demo](https://github.com/meredithcoyne/employee_tracker#Demo)
 * [Questions](https://github.com/meredithcoyne/employee_tracker#Questions)
 * [License](https://github.com/meredithcoyne/employee_tracker#License)

## Installation
------
1. Download or clone repository
2. Node.js is required to run the application
3. `npm install` to install the required npm packages
4. `npm init -y` to install package.json file
5. `npm install figlet` to install figlet graphics
6. `npm install mysql` to install mysql
7. `npm i inquirer` to install default

## Usage
------
* To start using the application, use mySQL Workbench to setup the database using this file

    [scheme.sql](main/db/schema.sql)

* The application is invoked by running `node index.js` in the command line

* Follow the prompts to finish application

## Resources
------
* JavaScript
* Node.js
* MySQL
* npm packages to install

## Demo
------
![Employee Management System](assets\employee_management.gif)

* [Video Demo]()

* [Deployed Webiste](https://meredithcoyne.github.io/employee_tracker/)

## Questions
  ------
  For any questions, please contact me via github or e-mail.

  * Checkout my [GitHub profile](https://github.com/meredithcoyne/employee_tracker)

  * Any additional questions or feed back, feel free to [send an email](mailto:meredithleigh.coyne@gmail.com).

  ## License
  Copyright 2021 Meredith Coyne

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

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

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


text:
Once your full node is up and running, you need to apply it to make him eligible as a masternode.

## Getting sufficient TOMO
As 50'000 TOMO are required to apply, the first thing to do is to fill out the following [form](https://docs.google.com/forms/d/183UxYRET9I183L7lFHCredjaTd9oj4kmf4UdH7eLNNs):

<iframe src="https://docs.google.com/forms/d/e/1FAIpQLSf0BiG8Rs5v4ItkwykgWUXsavLRZNA9W_EHTDis7klk5mNJnw/viewform?embedded=true" width="640" height="900" frameborder="0" marginheight="0" marginwidth="0">Loading...</iframe>

Our team will then review your request and send you the required funds.

*Note: Those TOMO are only usable in testnet, they have absolutely no trading value*

## Applying to become a masternode
You can now apply by going on the [TomoMaster](https://master.testnet.tomochain.com) page.
Login with the wallet that contains your newly received 50'000 TOMO.

On the top right corner, click on "Become a Candidate".

Enter the amount of TOMO you want to deposit (minimum 50'000).

Enter your coinbase address. This is the public key of the account that your masternode is using.
If your are running your node with `tmn`, you can simply run `tmn inspect` to get it.

Confirm with apply and proceed to make the payement.

Your full node will now be listed on TomoMaster.
People can view its details and vote for it.

If your node is in the top 150 most voted nodes, it will be promoted as a masternode and will start producing blocks at the next epoch.

## Resigning your masternode
In case you want to stop your node, you need to resign it from the governance first in order to retrieve your locked funds.
Access [TomoMaster](https://master.testnet.tomochain.com), go to your candidate detail page, and click the `Resign` button.
Your funds will be available to withdraw 30 days after the resignation.

After resigning successfully, you can stop your node. If you ran it with `tmn`, simply run:
```
tmn remove
```

At this point, your masternode is completly terminated.

repository: patrickburm/docs

repo_name: patrickburm/docs


text:
# Orders manager

## Launching project:

Start by installing Python3.6 on your system. You'll also need pipenv.

1. Clone project
2. Create empty file `.env`
3. Open `develop.env` file. Copy it's content to `.env` file
4. run `pipenv sync` in project root. It will create virtual environment
5. run `pipenv shell` to open shell of new virtual environment
6. run `python manage.py migrate` to apply all migrations
7. run `python manage.py createsuperuser` to create user
8. run `python manage.py runserver` to run django server
9. go to `<IP_ADDRESS>:8000` in your favorite browser

repository: DmitryLenko/orders-manager

repo_name: DmitryLenko/orders-manager


text:
# Iron
Scaffolding for a number of term-based enumeration synthesis tools.

## Dependencies

This library requires `containers`, which can be installed by running `opam install containers`.

## Installation

Setup requires `oasis`.

After cloning, simply navigate to the repository and run:
```
make
make install
```

## Usage

Link against the package `iron`. Useful modules include `Term` and `Zipper`.


text:
# pull-ws

Use websockets via pull-stream interface. both client and server.

[![NPM](https://nodei.co/npm/pull-ws.png)](https://nodei.co/npm/pull-ws/)

[![unstable](https://img.shields.io/badge/stability-unstable-yellowgreen.svg)](https://github.com/dominictarr/stability#unstable) [![Build Status](https://img.shields.io/travis/DamonOehlman/pull-ws.svg?branch=master)](https://travis-ci.org/DamonOehlman/pull-ws)

## example - client
``` js
var connect = require('pull-ws/client')
// OR: require('pull-ws').connect

connect(WS_URL, function (err, stream) {
  if(err) throw err //handle err
  pull(source, stream, sink)
})

```
## example - server

``` js
var createServer = require('pull-ws/server')
createServer(function (stream) {
  //pipe the stream somewhere.
  //eg, echo server
  pull(stream, stream)
}).listen(PORT)
```

## api

### `connect = require('pull-ws/client')`

`connect(url, cb | {binary: boolean, onConnect: cb})`

Create a websocket client connection. set binary: true
to get a stream of arrayBuffers (on the browser).
defaults to true on node, but to strings on the browser.
this may cause a problems if your application assumes binary.

else, just provide the callback.

``` js
connect(url, function (err, stream) {
  ...
})
```

### `createServer = require('pull-ws/server')`

create pull stream websocket servers.
the servers take a lot more options than clients.

`createServer(opts?, onConnection)`

`onConnect(stream)` is called every time a connection is received.

`opts` takes the same server options as [ws module](https://github.com/websockets/ws/blob/master/doc/ws.md#new-wsserveroptions-callback)

#### example

one duplex service you may want to use this with is [muxrpc](https://github.com/dominictarr/muxrpc)

``` js
var ws = require('pull-ws')
var pull = require('pull-stream')

ws.createServer(function (stream) {
  //pipe duplex style to your service.
  pull(stream, service.createStream(), stream)
})
.listen(9999)

var stream = ws.connect('ws://localhost:9999')

pull(stream, client.createStream(), stream)
```

if the connection fails, the first read from the stream will be an error,
otherwise, to get a handle of stream end/error pass a callback to connect.

``` js
ws.connect('ws://localhost:9999', function (err, stream) {
  if(err) return handleError(err)
  //stream is now ready
})

```

To run the server over TLS:

```js
var tlsOpts = {
  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
};
ws.createServer(tlsOpts, function (stream) {
  //pipe duplex style to your service.
  pull(stream, service.createStream(), stream)
})
.listen(9999)
```

To add client-authentication to the server, you can set `verifyClient`.
[Documentation here](https://github.com/websockets/ws/blob/master/doc/ws.md#optionsverifyclient).

```js
function verifyClient (info) {
  return info.secure == true
}
ws.createServer({ verifyClient: verifyClient }, onStream)
```

## use with an http server

if you have an http server that you also need to serve stuff
over, and want to use a single port, use the `server` option.

``` js
var http = require('http')
var server = http.createServer(function(req, res){...}).listen(....)
ws.createServer({server: server}, function (stream) { ... })

```

### core, websocket wrapping functions

these modules are used internally, to wrap a websocket.
you probably won't need to touch these,
but they are documented anyway.

### `require('pull-ws/duplex')(socket, opts?)`

turn a websocket into a duplex pull stream.
If provided, `opts` is passed to `pws.sink(socket, opts)`.

Websockets do not support half open mode.
[see allowHalfOpen option in net module](
http://nodejs.org/api/net.html#net_net_createserver_options_connectionlistener)

If you have a protocol that assumes halfOpen connections, but are using
a networking protocol like websockets that does not support it, I suggest
using [pull-goodbye](https://github.com/dominictarr/pull-goodbye) with your
protocol.

The duplex stream will also contain a copy of the properties from
the http request that became the websocket. they are `method`, `url`,
`headers` and `upgrade`.

also exposed at: `var duplex = require('pull-ws')`

### `require('pull-ws/sink')(socket, opts?)`

Create a pull-stream `Sink` that will write data to the `socket`.
`opts` may be `{closeOnEnd: true, onClose: onClose}`.
`onClose` will be called when the sink ends. If `closeOnEnd=false`
the stream will not close, it will just stop emitting data.
(by default `closeOnEnd` is true)

If `opts` is a function, then `onClose = opts; opts.closeOnEnd = true`.

```js
var pull = require('pull-stream');
var wsSink = require('pull-ws');

// connect to the echo endpoint for test/server.js
var socket = new WebSocket('wss://echo.websocket.org');

// write values to the socket
pull(
  pull.infinite(function() {
    return 'hello @ ' + Date.now()
  }),
  // throttle so it doesn't go nuts
  pull.asyncMap(function(value, cb) {
    setTimeout(function() {
      cb(null, value);
    }, 100);
  }),
  wsSink(socket)
);

socket.addEventListener('message', function(evt) {
  console.log('received: ' + evt.data);
});

```

also exposed at `require('pull-ws').sink`

### `require('pull-ws/source')(socket)`

Create a pull-stream `Source` that will read data from the `socket`.

```js
var pull = require('pull-stream');

// we just need the source, so cherrypick
var wsSource = require('pull-ws/source');

pull(
  // connect to the test/server.js endpoint
  wsSource(new WebSocket('ws://localhost:3000/read')),
  pull.log()
);

```

also exposed at `require('pull-ws').source`

# LICENSE

MIT

repository: pull-stream/pull-ws

repo_name: pull-stream/pull-ws


text:
---
layout: post
title: How to use Bootstrap CSS Styles in AMP Pages
description: This article explains how to remove unused Bootstrap CSS Styles and use the rest of the styles in AMP pages.
date: 2019-12-19 00:00:00 +08:00:00
image: /assets/2019-12-19-how-to-use-bootstrap-css-styles-in-amp-pages/banner.jpg
categories:
    - code
tags:
    - amp
---

## Introduction

AMP does not allow developers to import Bootstrap CSS Styles from any CDN, because Bootstrap has lots of styles so that it can make page rendering slow. Is it means we can not use Bootstrap to build responsive pages? No. You can learn the best practice to use Bootstrap in your AMP Pages correctly.

## 1. Start a new website project

You can use Jekyll to generate and manage a static website project. Read [Jekyll Beginner Guide](/jekyll-beginner-guide.html) to learn it in 5 minutes.

Run command `jekyll new demo-website` to create a static website project.

## 2. Create *_includes/head_amp.html*

1. Create a folder named *_includes* in the root directory of your website project.
2. Create a file named *head_amp.html* in *_includes* folder.
3. Paste the below codes into *head_amp.html*.

```html
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    {% raw %}
    {% capture styles %}
    {% include styles.scss %}
    {% endcapture %}
    {% endraw %}
    <style amp-custom>
        {% raw %}
        {{ styles | scssify }}
        {% endraw %}
    </style>
    <style amp-boilerplate>body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}</style><noscript><style amp-boilerplate>body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}</style></noscript>
</head>
```

## 3. Create *_layouts/default_amp.html*

1. Create a folder named *_layouts* in the root directory of your website project.
2. Create a file named *default_amp.html* in *_includes* folder.
3. Paste the below codes into *default_amp.html*.

```html
<!DOCTYPE html>
<html amp lang="{{ page.lang | default: site.lang | default: "en" }}">
{% raw %}
{%- include head_amp.html -%}
{% endraw %}
<body>
    <main class="page-content" aria-label="Content">
        <div class="wrapper">
            {% raw %}
            {{ content }}
            {% endraw %}
        </div>
    </main>
</body>
</html>
```

## 4. Create *_includes/styles.scss* to save custom styles

Run command `touch _includes/styles.scss` in the root directory of your website project.

## 5. Create a demo page

1. Create a file named `amp.html` in the root directory of your website project.
2. Paste the below codes into `amp.html`.

```html
---
layout: default_amp
---

<h1>Example heading <span class="badge badge-secondary">New</span></h1>
<h2>Example heading <span class="badge badge-secondary">New</span></h2>
<h3>Example heading <span class="badge badge-secondary">New</span></h3>
<h4>Example heading <span class="badge badge-secondary">New</span></h4>
<h5>Example heading <span class="badge badge-secondary">New</span></h5>
<h6>Example heading <span class="badge badge-secondary">New</span></h6>
```

## 6. Remove unused Bootstrap CSS styles

1. Open [UnCSS Online](https://uncss-online.com)

    ![UnCSS Online](/assets/2019-12-19-how-to-use-bootstrap-css-styles-in-amp-pages/uncss.jpg)

2. Copy HTML from *amp.html* to the left text box.
3. Paste the source code of Bootstrap CSS to the right text box.
4. Press **UNCSS MY STYLES**
5. Copy the source code from the bottom text box.

## 7. Use the elegant Bootstrap CSS

Paste the source code that you just copied into *_includes/styles.scss*.

## 8. Run your website

1. Run command `jekyll serve` in your prompt in the root directory of your website.
2. Open `http://localhost:4000#development=1` in your **Chrome**.

    *Note*: `#development=1` can start AMP validator, any exceptions will be printed on the console.

![Result](/assets/2019-12-19-how-to-use-bootstrap-css-styles-in-amp-pages/result.jpg)

*You can download full source code of the above demo from [my Github repository](https://github.com/miguoliang/effective-jekyll.git)*

## Conclusion

AMP is strict, Bootstrap is convenient and powerful, but they are not compatible with each other by default. What we need in the article is to remove unused Bootstrap CSS Styles and make useful styles imported inline. I hope it helps.


text:
---
title: odo ${TAG_NAME} Released
author: $GITHUB_ACTOR
author_url: https://github.com/$GITHUB_ACTOR
author_image_url: https://github.com/$GITHUB_ACTOR.png
image: https://raw.githubusercontent.com/redhat-developer/odo/main/docs/website/static/img/logo.png
tags: ["release"]
slug: odo-${TAG_NAME}
---

odo `${TAG_NAME}` is now out!

<!--truncate-->

To install `odo`, follow [the installation guide](../docs/overview/installation).

## Notable Changes
Check this Playlist for an overview of the most notable changes in this release: [TODO Add Link to Youtube Playlist]

### Features

[TODO - Complete with embedded demos!]

## Detailed Changelog

As with every release, you can find the full list of changes and bug fixes on the [GitHub release page](https://github.com/${GITHUB_REPOSITORY}/releases/tag/${TAG_NAME}).

repository: keithc-ca/odo

repo_name: keithc-ca/odo


text:
---
description: This section describes how to send Target mobile app activity information to Adobe Analytics for postAhoc segmentation.
seo-description: This section describes how to send Target mobile app activity information to Adobe Analytics for postAhoc segmentation.
seo-title: Send activity information to Adobe Analytics
title: Send activity information to Adobe Analytics
uuid: 2ca1ebfe-5008-4a73-a032-1ad81f062925
---

# Send activity information to Adobe Analytics{#send-activity-information-to-adobe-analytics}

This section describes how to send Target mobile app activity information to Adobe Analytics for postAhoc segmentation.

**Prerequisites**

* This integration requires that Analytics and Target are implemented using the mobile SDK.
* Ensure that your report suite is enabled to receive Activity information from Target.

  This is usually done by adding the Target client code to the Analytics report suite. This might be enabled already if you are using the SiteCatalyst-Test&Target integration for web activities. Contact Adobe Client Care if you have any questions about this step.

1. Obtain the activity information.

   If you include a string like the following in your experience content, Target returns the campaign information that you can send to Analytics:

   ```
   ${campaign.id}:${campaign.recipe.id}:${campaign.recipe.trafficType}
   ```

   Replace the text in your experience json code with something like the following example:

   ```
   {
     "tntVal": ${campaign.id}:${campaign.recipe.id}:${campaign.recipe.trafficType}",
     "title":"Welcome Message",
     "message":"Get Free Shipping Today!"
   }
   ```

   In this example, a node with the variable ' `tntVal`' is added to obtain the Activity information. Add similar code for the other experiences, with an appropriate title and message.

   This string delivers a number (such as 115110:0:0) in the response from Target. This indicates the Activity ID, experience ID, and traffic Type. The following is a smple response from Target:

   ```
   {
     "tntVal": 115110:0:0",
     "title":"Welcome Message",
     "message":"Get Free Shipping Today!"
   }
   ```

1. Parse the JSON object.

   Parse the response that came back from Target in the callback. You can use NSJSONSerialization to parse this response and store it in a dict or an array.

   Refer to the [NSJSONSerialization documentation](https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSJSONSerialization_Class/#//apple_ref/occ/clm/NSJSONSerialization/JSONObjectWithData:options:error) for more information.
1. Send the data to Analytics.

   Add the parsed activity information (such as `tntVal` in the above response) to your context data object in an analytics call. This Analytics call containing the context data can be fired immediately or it can wait until the next Analytics call is fired.

   For example, this call can be fired in the callback of the `targetLoadRequest` call:

   ```
   [ADBMobile trackAction:@"Welcome Screen"
         data:@{@"&&tnt" : tntVal from response}];
   ```

   >[!NOTE]
   >
   >`&&tnt`is a reserved event key in the mobile SDK. The post-classification of the `tntVal` variable in Analytics works in the same way in the mobile SDK as it does in on the web (JavaScript). Once the information is processed in Analytics, you should see activity and experience names in the Analytics interface.


text:
# Do not report warnings about conflicts in `Config` field

- **Pull-request**: [#122](https://github.com/SchrodingersGat/KiBoM/pull/122)
- **Opened**: 2020-07-18
- **Status**: Open
- **Branch**: no_conflict_in_config

## Description

Do not report warnings about conflicts in `Config` field

When using variants the Config fields may be quite different between
components.
Reporting conflicts in Config generates noise.

repository: INTI-CMNB/KiBoM

repo_name: INTI-CMNB/KiBoM


text:
This guide will teach you how to build a simple app using Ember from scratch.

We'll cover these steps:

1. Installing Ember.
2. Creating a new application.
3. Defining a route.
4. Writing a UI component.
5. Building your app to be deployed to production.

## Install Ember

You can install Ember with a single command using npm,
the Node.js package manager.
Type this into your terminal:

```bash
npm install -g ember-cli
```

Don't have npm? [Learn how to install Node.js and npm here](https://docs.npmjs.com/getting-started/installing-node).
For a full list of dependencies necessary for an Ember CLI project,
consult our [Installing Ember](../../getting-started/) guide.

## Create a New Application

Once you've installed Ember CLI via npm,
you will have access to a new `ember` command in your terminal.
You can use the `ember new` command to create a new application.

```bash
ember new ember-quickstart
```

This one command will create a new directory called `ember-quickstart` and set up a new Ember application inside of it.
Out of the box, your application will include:

* A development server.
* Template compilation.
* JavaScript and CSS minification.
* ES2015 features via Babel.

By providing everything you need to build production-ready web applications in an integrated package,
Ember makes starting new projects a breeze.

Let's make sure everything is working properly.
`cd` into the application directory `ember-quickstart` and start the development server by typing:

```bash
cd ember-quickstart
ember serve
```

After a few seconds, you should see output that looks like this:

```text
Livereload server on http://localhost:7020
Serving on http://localhost:4200/
```

(To stop the server at any time, type Ctrl-C in your terminal.)

Open [`http://localhost:4200`](http://localhost:4200) in your browser of choice.
You should see an Ember welcome page and not much else.
Congratulations! You just created and booted your first Ember app.

We will start by editing the `application` template.
This template is always on screen while the user has your application loaded.
In your editor, open `app/templates/application.hbs` and change it to the following:

```handlebars {data-filename="app/templates/application.hbs"}
<h1>PeopleTracker</h1>

{{outlet}}
```

Ember detects the changed file and automatically reloads the page for you in the background.
You should see that the welcome page has been replaced by "PeopleTracker".
You also added an `{{outlet}}` to this page,
which means that any nested route will be rendered in that place.

## Define a Route

Let's build an application that shows a list of scientists.
To do that, the first step is to create a route.
For now, you can think of routes as being the different pages that make up your application.

Ember comes with _generators_ that automate the boilerplate code for common tasks.
To generate a route, type this in a new terminal window in your `ember-quickstart` directory:

```bash
ember generate route scientists
```

You'll see output like this:

```text
installing route
  create app/routes/scientists.js
  create app/templates/scientists.hbs
updating router
  add route scientists
installing route-test
  create tests/unit/routes/scientists-test.js
```

That is Ember telling you that it has created:

1. A template to be displayed when the user visits `/scientists`.
2. A `Route` object that fetches the model used by that template.
3. An entry in the application's router (located in `app/router.js`).
4. A unit test for this route.

Open the newly-created template in `app/templates/scientists.hbs` and add the following HTML:

```handlebars {data-filename="app/templates/scientists.hbs"}
<h2>List of Scientists</h2>
```

In your browser, open [`http://localhost:4200/scientists`](http://localhost:4200/scientists).
You should see the `<h2>` you put in the `scientists.hbs` template,
right below the `<h1>` from our `application.hbs` template.

Now that we've got the `scientists` template rendering,
let's give it some data to render.
We do that by specifying a _model_ for that route,
and we can specify a model by editing `app/routes/scientists.js`.

We'll take the code created for us by the generator and add a `model()` method to the `Route`:

```javascript {data-filename="app/routes/scientists.js" data-diff="+4,+5,+6"}
import Route from '@ember/routing/route';

export default Route.extend({
  model() {
    return ['Marie Curie', 'Mae Jemison', 'Albert Hofmann'];
  }
});
```

This code example uses the latest features in JavaScript,
some of which you may not be familiar with.
Learn more with this [overview of the newest JavaScript features](https://ponyfoo.com/articles/es6).

In a route's `model()` method, you return whatever data you want to make available to the template.
If you need to fetch data asynchronously,
the `model()` method supports any library that uses [JavaScript Promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).

Now let's tell Ember how to turn that array of strings into HTML.
Open the `scientists` template and add the following code to loop through the array and print it:

```handlebars {data-filename="app/templates/scientists.hbs" data-diff="+3,+4,+5,+6,+7"}
<h2>List of Scientists</h2>

<ul>
  {{#each model as |scientist|}}
    <li>{{scientist}}</li>
  {{/each}}
</ul>
```

Here, we use the `each` helper to loop over each item in the array we provided from the `model()` hook and print it inside an `<li>` element.

## Create a UI Component

As your application grows, you will notice you are sharing UI elements between multiple pages,
or using them multiple times on the same page.
Ember makes it easy to refactor your templates into reusable components.

Let's create a `people-list` component that we can use in multiple places to show a list of people.

As usual, there's a generator that makes this easy for us.
Make a new component by typing:

```bash
ember generate component people-list
```

Copy and paste the `scientists` template into the `people-list` component's template and edit it to look as follows:

```handlebars {data-filename="app/templates/components/people-list.hbs"}
<h2>{{title}}</h2>

<ul>
  {{#each people as |person|}}
    <li>{{person}}</li>
  {{/each}}
</ul>
```

Note that we've changed the title from a hard-coded string ("List of Scientists") to a dynamic property (`{{title}}`).
We've also renamed `scientist` to the more-generic `person`,
decreasing the coupling of our component to where it's used.

Save this template and switch back to the `scientists` template.
Replace all our old code with our new componentized version.
Components look like HTML tags but instead of using angle brackets (`<tag>`) they use double curly braces (`{{component}}`).

We're going to tell our component:

1. What title to use, via the `title` attribute.
2. What array of people to use, via the `people` attribute. We'll
   provide this route's `model` as the list of people.

```handlebars {data-filename="app/templates/scientists.hbs" data-diff="-1,-2,-3,-4,-5,-6,-7,+8"}
<h2>List of Scientists</h2>

<ul>
  {{#each model as |scientist|}}
    <li>{{scientist}}</li>
  {{/each}}
</ul>
{{people-list title="List of Scientists" people=model}}
```

Go back to your browser and you should see that the UI looks identical.
The only difference is that now we've componentized our list into a version that's more reusable and more maintainable.

You can see this in action if you create a new route that shows a different list of people.
As an exercise for the reader,
you may try to create a `programmers` route that shows a list of famous programmers.
By re-using the `people-list` component, you can do it in almost no code at all.

## Click Events

So far, your application is listing data,
but there is no way for the user to interact with the information.
In web applications you often want to listen for user events like clicks or hovers.
Ember makes this easy to do.
First , add a `<button>` with an `action` helper to the `li` in your `people-list` component.

```handlebars {data-filename="app/templates/components/people-list.hbs" data-diff="-5,+6"}
<h2>{{title}}</h2>

<ul>
  {{#each people as |person|}}
    <li>{{person}}</li>
    <li><button {{action "showPerson" person}}>{{person}}</button></li>
  {{/each}}
</ul>
```

The `action` helper allows you to add event listeners to elements and call named functions.
By default, the `action` helper adds a `click` event listener,
but it can be used to listen for any element event.
Now, when the `li` element is clicked a `showPerson` function will be called from the `actions` object in the `people-list` component.
Think of this like calling `this.actions.showPerson(person)` from our template.

To handle this function call you need to modify the `people-list` component file to add the function to be called.
In the component, add an `actions` object with a `showPerson` function that alerts the first argument.

```javascript {data-filename="app/components/people-list.js" data-diff="+4,+5,+6,+7,+8"}
import Component from '@ember/component';

export default Component.extend({
  actions: {
    showPerson(person) {
      alert(person);
    }
  }
});
```

Now in the browser when a scientist's name is clicked,
this function is called and the person's name is alerted.

## Building For Production

Now that we've written our application and verified that it works in development,
it's time to get it ready to deploy to our users.

To do so, run the following command:

```bash
ember build --env production
```

The `build` command packages up all of the assets that make up your
application—JavaScript, templates, CSS, web fonts, images, and
more.

In this case, we told Ember to build for the production environment via the `--env` flag.
This creates an optimized bundle that's ready to upload to your web host.
Once the build finishes,
you'll find all of the concatenated and minified assets in your application's `dist/` directory.

The Ember community values collaboration and building common tools that everyone relies on.
If you're interested in deploying your app to production in a fast and reliable way,
check out the [Ember CLI Deploy](http://ember-cli-deploy.com/) addon.

If you deploy your application to an Apache web server, first create a new virtual host for the application.
To make sure all routes are handled by index.html,
add the following directive to the application's virtual host configuration:

```apacheconf
FallbackResource index.html
```

<!-- eof - needed for pages that end in a code block  -->

repository: ember-learn/guides-source

repo_name: ember-learn/guides-source


text:
---
title: "State Senate"
date: 2020-01-08T22:36:39-08:00
position: Scott Wiener
weight: 4
headshot: /img/2020-march/california/scott-wiener.jpg
website: https://www.scottwiener.com/
donate: https://www.scottwiener.com/donate
---

### Scott Wiener

Senator Scott Wiener is a huge champion of rights in the digital age. After
[Trump's FCC repealed net neutrality](https://techcrunch.com/2019/10/01/court-says-fccs-unhinged-net-neutrality-repeal-cant-stop-state-laws/),
Senator Wiener proposed a [California implementation of Net Neutrality](https://sd11.senate.ca.gov/news/20180822-senator-wiener%E2%80%99s-net-neutrality-bill-passes-out-its-final-committee-and-advances).
His legislation ensures that California can continue to be the cradle of the
tech industry and that large telecom corporations can't unfairly quash new
startups.

{{< blockquote
    content="\"Restoring full net neutrality protections in California is within sight,\" said Senator Wiener. \"The internet is at the heart of 21st century life - our economy, our public safety and health systems, our democracy - and we must protect it. The core premise of net neutrality is that we get to decide where we go on the internet, as opposed to telecom and cable companies telling us where to go.\""
    source_text="Scott Wiener"
    source_url="https://sd11.senate.ca.gov/news/20180822-senator-wiener%E2%80%99s-net-neutrality-bill-passes-out-its-final-committee-and-advances"
    >}}

In addition to his excellent pro-innovation legislation, Senator Wiener has been
consistently pro-housing and made it clear that it was bad government, not the
tech industry that led to our housing shortage:

{{< tweet<PHONE_NUMBER>421233664 >}}

Senator Wiener stands alone among California elected officials in both his
efficacy and his forward-thinking. He deserves your vote.

repository: MatrixFrog/tech-worker-voter-guide

repo_name: MatrixFrog/tech-worker-voter-guide


text:
#  Question
What size image does this Dockerfile create? What size of archive does it create if you export it to a tarball? What else is in the image that was built?

####  Answer:
<pre>
sudo docker build -t testimage .
sudo docker images --format "{{.Size}}" testimage
2
sudo docker save -o test.tar testimage

ls -lh test.tar|awk '{print $5}'
11k
</pre>


text:
# Flask + Next.js example

## Overview

This example shows how you can serve Next.js server-side rendered (SSR) files alongside Flask
endpoints. This is potentially useful for existing Flask projects that want to transition to a full
Next.js frontend and Flask backend without an all-or-nothing cutover.

## How to run this

### Render Next.js static assets
```
yarn install
yarn build
```
### Run the Flask app
```
pip install -r requirements.txt
FLASK_APP=app.py flask run
```

repository: beager/flask-next-example

repo_name: beager/flask-next-example


text:
0.6 to 0.7
==========

* [Model] `BaseModel::toNvp` was removed.
* [Model] `BaseModel::fromNvp` was removed.
* [Doctrine] `Payum\Paypal\ExpressCheckout\Nvp\Model\PaymentDetails` require migration. New field `others` is added.
* [Doctrine] `Payum\Paypal\ExpressCheckout\Nvp\Model\RecurringPaymentDetails` require migration. New field `others` is added.
* [Doctrine] `Payum\Paypal\ExpressCheckout\Nvp\Bridge\Doctrine\Entity\PaymentDetails` was deprecated and now removed. Use `Payum\Paypal\ExpressCheckout\Nvp\Model\PaymentDetails` instead.
* [Doctrine] `Payum\Paypal\ExpressCheckout\Nvp\Bridge\Doctrine\Entity\RecurringPaymentDetails` was deprecated and now removed. Use `Payum\Paypal\ExpressCheckout\Nvp\Model\RecurringPaymentDetails` instead.
* [Doctrine] `Payum\Paypal\ExpressCheckout\Nvp\Bridge\Doctrine\Document\PaymentDetails` was deprecated and now removed. Use `Payum\Paypal\ExpressCheckout\Nvp\Model\PaymentDetails` instead.
* [Doctrine] `Payum\Paypal\ExpressCheckout\Nvp\Bridge\Doctrine\Document\RecurringPaymentDetails` was deprecated and now removed. Use `Payum\Paypal\ExpressCheckout\Nvp\Model\RecurringPaymentDetails` instead.

0.4 to 0.5
==========

* [Doctrine] `PaymentDetails` mapping schema was updated. Two fields added: `returnurl`, `cancelurl`.

0.3 to 0.4
==========

* `PaymentInstruction` was renamed to `PaymentDetails` and moved to `Model` namespace.
* [Doctrine] `PaymentDetails` mapping schema was updated. Two fields added: `l_billingtypennn`, `l_billingagreementdescriptionnnn`

0.2 to 0.3
==========

* Remove `toNvp` and `fromNvp` from `PaymentInstruction` class.
* `Payment` class was removed use `Payum\Payment` instead.

0.1 to 0.2
==========

* `SyncRequest` was moved to core lib.

repository: stefanorg/PaypalExpressCheckoutNvp

repo_name: stefanorg/PaypalExpressCheckoutNvp