text:
# Semester-Template
A template repo to setup a university semesters worth of course. Follow the TODO list below to get everything setup, and fork the Repo to suit you if you want to create your own template. **KEEP IN MIND, by default the .gitignore file makes the system ignore everything kept in the following folders:** ```
/Assignments    /Handouts    /Readings``` see the last point in the **course todo** for details on how to get this to work.

## TODO
- [ ] Add course list to [Courses section](#courses)
- [ ] Delete unnecessary months from [Assignment due dates & Important dates](#assignment-due-dates--important-dates) & the [Table of contents](#table-of-contents)
- [ ] Add an image of your schedule (as a .png file) to the main directory and call it ```schedule.png``` or delete that section
- [ ] Add each course as a directory following the template under ```/CODE-111; This is where the course name goes``` & fill out it's readme.

## Table of contents

- [Courses](#courses)
- [Schedule](#schedule)
- [Assignment due dates & Important dates](#assignment-due-dates--important-dates)
    - [January](#january)
    - [February](#february)
    - [March](#march)
    - [April](#april)
    - [May](#may)
    - [June](#june)
    - [July](#july)
    - [August](#august)
    - [September](#september)
    - [October](#october)
    - [November](#november)
    - [December](#december)

## Courses

CODE-111; This is where the course name goes

## Schedule

![Schedule](./schedule.png)

I would recommend adding a image of your schedule in the main directory. Call it schedule.png and it will show up here automatically.

## Assignment due dates & Important dates

You can use any format for this section, but I would recommend going in order of what's due, and then [striking through](https://saijogeorge.com/strikethrough-text-generator/) as you complete the assignments.

### January

1st - This item is due

### February

1st - This item is due

### March

1st - This item is due

### April

1st - This item is due

### May

1st - This item is due

### June

1st - This item is due

### July

1st - This item is due

### August

1st - This item is due

### September

1st - This item is due

### October

1st - This item is due

### November

1st - This item is due

### December

1st - This item is due


text:
# weatherdashboard-hw6
# Weather Dashboard Homework Assignment 6

## Michigan State University Coding Bootcamp

Project By:

Ian Hennessey

GitHub Profile:  <https://github.com/atleastitsanethosman>

Project GitHub Repository: <https://github.com/atleastitsanethosman/weatherdashboard-hw6>

Project URL: <https://atleastitsanethosman.github.io/weatherdashboard-hw6/>

## Project Description
The goal of this project was to generate a weather dashboard for a traveler.  The dashboard allowed the traveler to search by city and find the weather for the current day as well as the 5 days going forward.  It would also safe a history of recent searches and include some visual elements to help the traveler understand the weather conditions quickly.

## Footage of Deployed Application
![display of using both the search bar and recent history to pull information.](./assets/img/WeatherDashboard.gif)

## Project Elements:

1. A input area allowing the traveler to search by location.

2. A prior searches area, limited to 5 recent searches, allowing the traveler to quickly pull up weather data from recently visited cities.

3. A large card showing weather data for the current day including an icon reflecting the conditions and a color coded note on the UV index to indicate severity of UVI conditions.

4. Smaller cards showing weather conditions for the next 5 days along with icons to give a visual representation of conditions.

## Citations:

Moment <https://momentjs.com/>

jQuery <https://jquery.com/>

Google Fonts <https://fonts.google.com/>

openweathermap API <https://openweathermap.org/api>

## License:

Copyright (c) 2021 Ian Hennessey
Licensed under the [MIT LICENSE](LICENSE)

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
# Person-blog

### **This project was done using Python 3.6  and Flask.**

# DESCRIPTION

This is a for personal blogging website where you can create and share your opinions and other users can read and comment on them.

## User Story

- Users can see the post other people have published.

- Users/Writers can sign in to the blog.

- Users can register on the website.

-  Users can create a blog from the application.

- Users can receive a welcoming email once they sign up.

- Users can view the posts they have created in their profile page..

- Users can comment on the different posts.

- Users can submit a post in any category.

- Users can view the different categories.

# **SETUP/INSTALLATION.**
## Prerequisites

To work with FLASK BLOG App you need to have some few prerequisites.

- Python3.6

- pip

- Flask

- Virtual environment (virtualenv)

- Code/text editor

- Terminal

### **To work With PERSON BLOG**

1. You will need Internet connection.

2. You will also need python installed and knowledge

3. Installing Flask and other Modules

    `python3.6 -m pip install Flask`
    `python3.6 -m pip install Flask-Bootstrap`
    `python3.6 -m pip install Flask-Script`
    `python3.6 -m pip install -r requirements.txt`

4. On your **bash** terminal Run the command:-

```
  $ chmod +x start.sh
  $ ./start.sh
```
OR run:
* $ python3.6 run.py runserver

# Technologies Used

* Python 3.6
* Flask
* Postgresql
* MDBootstrap

# AUTHOR

* Huguette

## Support and Contact
---

-github-username: huguette135

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

branch_name: refs/heads/master


text:
# UltraFacade

In the context of UltraFacade, a Facade is an object-oriented creational design
pattern to implement the concept of facades and deals with the problem of
creating objects without specifying the exact class of object that will be
created.

## A Concrete Implementation

The concrete implentation in this library,
`JeremyKendall\UltraFacade\SplIteratorFacade`, is an example of how to properly
use a Facade.  It creates SPL Iterators based on a type string passed in at
runtime. The type string is the name of the SPL Iterator with 'Iterator'
removed (less typing FTW).  The second optional argument is used to pass
required params the the iterator's constructor.

``` php
$iterator = new SplIteratorFacade::facade('RecursiveDirectory', array(__DIR__));
```

While this specific facade implementation is production ready and should be
used if you have a use case for it, the intent is simply to demonstrate how the
Facade should be used.

## Installation

Installation is handled via [Composer][1].

``` json
{
    "require": {
        "jeremykendall/ultra-facade": "1.*"
    }
}
```
Please check the [UltraFacade page][2] at Packagist for the latest version.

[1]: http://getcomposer.org
[2]: https://packagist.org/packages/jeremykendall/ultra-facade

repository: jeremykendall/ultra-facade

repo_name: jeremykendall/ultra-facade


text:
---
layout: post
title: "Vim TagBar with Objective-C"
date: 2014-02-14 13:53
---

When working with large files in Vim,
[Tagbar](http://majutsushi.github.io/tagbar/) has become an invaluable
part of my workflow. It provides a succinct list of methods, modules,
variables and other language specific constructs. When I started trying
to spend more time in Vim writing Objective-C I was disappointed to see
that, out of the box, it was not supported.

Hopefully in the future it won't be difficult to set this up in Vim.
Currently ctags [already
has](https://svn.code.sf.net/p/ctags/code/trunk/objc.c) built in support
for Objective-C. Unfortunately there hasn't been a release of ctags
since 2009. As recommended in the [canonical how to
article](http://bastibe.de/2011-12-04-how-to-make-tagbar-work-with-objective-c.html)
you can attempt to use the trunk version of ctags and just define the
Tagbar settings. For me, this ended up producing a ton of
mis-categorized duplicates. I also opened and closed [an
issue](https://github.com/majutsushi/tagbar/issues/193) on the Tagbar
Github repo hoping that Objective-C support will be added by default in
the future.

The only other resource I could find about this issue was [this
gist](https://gist.github.com/yamaya/5598909). It uses regex to define
Objective-C to ctags and then match it with Tagbar. I improved it a
little bit and came up with this.  Please let me know if you see any way that this could be
improved.

gha_language: CSS

gha_license_id: MIT


text:
# OpenCloud autoloading

OpenCloud uses [Symfony 2's universal autoloader](https://github.com/symfony/symfony/blob/master/src/Symfony/Component/ClassLoader/UniversalClassLoader.php) to manager automatic class instantiation.

When your application references `php-opencloud.php`, we take care of registering the OpenCloud library classes for you. If you take a look at the file, you can see that it registers the root namespace for OpenCloud; thereby allowing all subsequent file includes to happen automatically:

```php
$classLoader = new ClassLoader;
$classLoader->registerNamespaces(array(
    'OpenCloud' => array(__DIR__, __DIR__ . '/../tests')
));
$classLoader->register();
```

The ClassLoader class above utilizes PHP's `spl_autoload_register` [native function](http://php.net/manual/en/function.spl-autoload-register.php), which allows users to specify a custom method for autoloading.

## Using multiple autoloaders

According to the official documentation:

> If there must be multiple autoload functions, spl_autoload_register() allows for this. It effectively creates a queue of autoload functions, and runs through each of them in the order they are defined.

PHP creates the queue for you, on the condition that you have multiple `spl_autoload_register` calls. It will iterate through each custom autoload method and attempt to include the PHP file; if it can't, it will move on to the next autoload method.

This means that to effectively use multiple autoload functions, you must include a conditional statement to make sure the class exists (i.e. allowing PHP to rollover to the next autoload function if the current one cannot locate the file you're looking for).

If your application requires a custom autoloading method, you might want to do something like this:

```php
$includePaths = array();
$includePaths[] = __DIR__ . '/Folder1/Folder2';

spl_autoload_register(function ($class) use ($includePaths) {
    foreach ($includePaths as $path) {
        $file = $path . '/' . strtolower($class) . '.class.php';
        if (is_file($file)) {
              include($file);
        }
    }
});

// Finished with my app's autoloader, so I'll allow OpenCloud to take over...

require '/path/to/lib/php-opencloud.php';

$connection = new \OpenCloud\OpenStack(...);

```

repository: AudiologyHoldings/php-opencloud

gha_language: PHP

gha_license_id: NOASSERTION

repo_name: AudiologyHoldings/php-opencloud


text:
---
layout:     post
title:      "How am I designing the light fixture?"
subtitle:   "Methods and goals"
date:       2016-06-30 8:45:00
author:     "Duana Severiano"
header-img: "img/posts/Duana_gh2.jpg"
comments: true
tags: [ Digital Fabrication ]
---

Hi!

To build such a complex shape as the shape of the White Royal butterfly’s egg, I’m using Rhinoceros 5.0 and Grasshopper and a list of accomplishments/steps to follow.
-	The first step is to define the spherical shape with hexagonal faces and pointed finished.
-	The second step is to apply a Voronoi pattern on each face, which will have a frame to guarantee support for the pattern. The pattern will permit the light to flow from the inside to the outside of the light fixture.
-	The third step is to build the portion the electronics will occupy, which will also be a base to sustain the spherical object.
-	The forth step is to program the particle photon and connect the components so they can be placed in their box.
-	The fifth step is to check the dimensions of the object and then print it. The sixth and last step is to assemble the light fixture and get ready to present it.


text:
### Sample

<!— Provide a link to the sample there’s an issue with e.g. https://github.com/xamarin/xamarin-forms-samples/tree/master/WebServices/TodoREST —>

### Description

<!-- Describe what the issue is -->

### Steps to Reproduce

1.
2.
3.

### Expected Behavior

### Actual Behavior

### Information

- IDE and IDE version: <!-- Visual Studio 2017 v15.6 / Visual Studio Mac v7.4 -->
- Platform with the issue: <!-- All that apply -->
  - iOS:  <!-- The version of the iOS SDK you are compiling against, e.g. 11.1 -->
  - Android: <!-- The version of the Android SDK you are compiling against, e.g. 8.0 -->
  - UWP:  <!-- The version of the UWP SDK you are compiling against, e.g. 16299 -->
- Device or simulator/emulator: <!-- State whether the problem occurs on a device or a simulator/emulator -->


text:
## Aggregate

With the command and event in place we can now start adding our business logic.
In Domain Driven Design all of this logic belongs within the aggregate which
for our example we will call name `BankAccount`.

And for our simple set of business rules, we will use two fields.

```rust,ignore
#[derive(Serialize, Default, Deserialize)]
pub struct BankAccount {
    opened: bool,
    // this is a floating point for our example, don't do this IRL
    balance: f64,
}
```

In order to operate within the `cqrs-es` framework, we will need the traits, `Default`, `Serialize` and `Deserialize`
(all usually derived) and we will implement `cqrs_es::Aggregate`, minus any of the business logic.

```rust
#[async_trait]
impl Aggregate for BankAccount {
    type Command = BankAccountCommand;
    type Event = BankAccountEvent;
    type Error = BankAccountError;
    type Services = BankAccountServices;

    // This identifier should be unique to the system.
    fn aggregate_type() -> String {
        "Account".to_string()
    }

    // The aggregate logic goes here. Note that this will be the _bulk_ of a CQRS system
    // so expect to use helper functions elsewhere to keep the code clean.
    async fn handle(&self, command: Self::Command, services: Self::Services) -> Result<Vec<Self::Event>, Self::Error> {
        todo!()
    }

    fn apply(&mut self, event: Self::Event) {
        match event {
            BankAccountEvent::AccountOpened { .. } => {
                self.opened = true
            }

            BankAccountEvent::CustomerDepositedMoney { amount: _, balance } => {
                self.balance = balance;
            }

            BankAccountEvent::CustomerWithdrewCash { amount: _, balance } => {
                self.balance = balance;
            }

            BankAccountEvent::CustomerWroteCheck {
                check_number: _,
                amount: _,
                balance,
            } => {
                self.balance = balance;
            }
        }

    }
}

```

### Identifying the aggregate when persisted

The `aggregate_type` method is used by the cqrs-es framework to uniquely identify the aggregate and event
when serialized for persistence. Each aggregate should use a unique value within your application.
```rust
    fn aggregate_type() -> String {
        "Account".to_string()
    }
```

### Handling commands

The `handle` method of this trait is where _all_ of the business logic will go, for now we will leave that out and just return an empty vector.

```rust
    // note that the aggregate is immutable and an error can be returned
    async fn handle(&self, command: Self::Command) -> Result<Vec<Self::Event>, AggregateError<Self::Error>> {
        todo!()
    }
```
The `handle` method does not allow any mutation of the aggregate, state should be changed _only_ by emitting events.

### Applying committed events

Once events have been committed they will need to be applied to the aggregate in order for it to update its state.
```rust
    // note the aggregate is mutable and there is no return type
    fn apply(&mut self, event: Self::Event) {
        match event {
            BankAccountEvent::AccountOpened { .. } => {
                self.opened = true
            }

            BankAccountEvent::CustomerDepositedMoney { amount: _, balance } => {
                self.balance = balance;
            }

            BankAccountEvent::CustomerWithdrewCash { amount: _, balance } => {
                self.balance = balance;
            }

            BankAccountEvent::CustomerWroteCheck {
                check_number: _,
                amount: _,
                balance,
            } => {
                self.balance = balance;
            }
        }
    }
```
Note that the `apply` function has no return value. The act of applying an event is simply bookkeeping, the action has
already taken place.

> An event is a historical fact, it can be ignored, but it should never cause an error.

repository: serverlesstechnology/cqrs

gha_language: Rust

repo_name: serverlesstechnology/cqrs


text:
# Ayesaac

This repository contains the source code for Ayesaac, a Python program to help blind people to find what they have lost in a room.

## Getting started

1. Pull the repo
1. Pull the files in git-lfs using `git-lfs pull`. (you may need `git lfs install` first).

It's recommended that you use [Docker](https://docker.com) for development to avoid fighting with dependencies, but you can always follow [these instructions](https://github.com/Aye-saac/aye-saac/wiki/Installing-things) if you want to have things running manually.

### Developing with Docker

Using `make build_image`, you can build an image which will be used for all services required by the system. Then, you can run it using `docker-compose up` and all related services will load up.

When creating the image, [models are downloaded](https://github.com/Aye-saac/aye-saac/blob/1163ff751be4800925af5ee39e1d84f858be9ea5/Dockerfile#L47) and [placed in the right place](https://github.com/Aye-saac/aye-saac/blob/1163ff751be4800925af5ee39e1d84f858be9ea5/Dockerfile#L69) to make life easier.

Note: Because they all need RabbitMQ to work, they will error and restart a bunch of times and then stabilise once RabbitMQ is ready and work properly.

### Architecture

![](docs/diagram_aye-saac_v3.png)

repository: fabrien/aye-saac

gha_language: Python

repo_name: fabrien/aye-saac


text:
# UK Income Tax
How much Income Tax you pay in each tax year depends on:

* How much of your income is above your Personal Allowance
* How much of your income falls within each tax band

Some income is tax-free.

All the figures are for the tax year from 6 April 2020 to 5 April 2021.

## Goal

Given a yearly salary amount before tax calculate an amount of income tax needed to be collected.

## Assumptions

For the purpose of this exercise we will make some assumptions to simplify the problem:

* All the income for a person in question is taxable and obtained during a single employment.
* The person in question does not claim any allowances or receive any taxable benefits from the employment.

## Tax-free Personal Allowance
The standard Personal Allowance is £12,500, which is the amount of income you do not have to pay tax on.

## Taxable Bands

Band | Taxable income | Tax rate
-- | -- | --
Personal Allowance | Up to £12,500 | 0%
Basic rate | £12,501 to £50,000 | 20%
Higher rate* | £50,001 to £150,000 | 40%
Additional rate* | over £150,000 | 45%

(Source: gov.uk)[https://www.gov.uk/income-tax-rates]

**You do not get a Personal Allowance on taxable income over £125,000.*

## Income over £100,000
Your Personal Allowance goes down by £1 for every £2 that your adjusted net income is above £100,000. This means your allowance is zero if your income is £125,000 or above.

For example at £*110,000* the Personal Allowance will be £*7,500*.

`12,500 - (110,000 - 100,000) / 2 = 7,500`

## Tax Bands After Deducting Personal Allowance

In order to avoid any confusion, we first deduct the effective personal allowance (which could be 0) and then use bands in the table below to calculate the tax.

Band | Adjusted Taxable income | Tax rate
-- | -- | --
Basic rate | 0 to £37,500 | 20%
Higher rate | £37,501 to £150,000 | 40%
Additional rate | over £150,000 | 45%

## Examples

Income | Tax | Notes
-- | -- | --
5,600 | 0 |
12,600 | 20 |
50,000 | 7,500 |
60,000 | 11,500 |
99,000 | 27,100 |
110,000 | 33,500|
125,000| 42,500|
155,000|54,750|
1,000,000|435,000|

## Getting started

```
$ cd js/problem
$ npm install
$ npm test
```

repository: ZeenaKareemAlhello/tdd-labs

repo_name: ZeenaKareemAlhello/tdd-labs


text:
# Bazel Release Playbook

This is the guide to conducting a Bazel release. This is especially relevant for
release managers, but will be of interest to anyone who is curious about the
release process.

## Preface

> For future reference and release managers - the release manager playbook should
> be treated like an IKEA manual. That means: Do not try to be smart, optimize /
> skip / reorder steps, otherwise chaos will ensue. Just follow it and the end
> result will be.. well, a usable piece of furniture, or a Bazel release
> (depending on the manual).
>
> Like aviation and workplace safety regulations, the playbook is written in the
> tears and blood of broken Bazelisks, pipelines, releases and Git branches.
> Assume that every step is exactly there for a reason, even if it might not be
> obvious. If you follow them to the letter, they are not error prone. Errors
> have only happened in the past, when a release manager thought it's ok to
> follow them by spirit instead. ;)
>
> -- @philwo

## One-time setup

These steps only have to be performed once, ever.

*   Make sure you are a member of the Bazel [Release Managers](https://github.com/orgs/bazelbuild/teams/release-managers/members) team on GitHub.
*   Make sure you are a member of the Bazel [release-managers](https://buildkite.com/organizations/bazel-trusted/teams/release-managers/members)
    group on BuildKite.  If that link does not work for you, ask one of the Buildkite org admins to add you to
    the group.
*   Set up github ssh key if you haven't already.
    *    https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/
*   Generate a new identifier for Google's internal Git mirror: https://bazel.googlesource.com/new-password (and paste the code in your shell).

## Preparing a new release

1.  [Create a release blockers milestone](https://github.com/bazelbuild/bazel/milestones/new) named "X.Y.Z release blockers" (case-sensitive), where we keep track of issues that must be resolved before the release goes out.
1.  [Create a release tracking issue](https://github.com/bazelbuild/bazel/issues/new?assignees=&labels=release%2Cteam-OSS%2CP1%2Ctype%3A+process&template=release.md&title=Release+X.Y+-+%24MONTH+%24YEAR) to keep the community updated about the progress of the release
1.  Create the branch for the release. The branch should always be named `release-X.Y.Z` (the `.Z` part is important). Cherry-pick PRs will be sent against this branch.
    *   The actual creation of the branch can be done via the GitHub UI or via the command line. How we choose the base commit of the branch depends on the type of the release:
    *   For patch releases (`X.Y.Z` where `Z>0`), the base commit should simply be `X.Y.(Z-1)`.
    *   For minor releases (`X.Y.0` where `Y>0`), the base commit should typically be `X.(Y-1).<current max Z>`.
    *   For major releases (`X.0.0`), the base commit is some "healthy" commit on the main branch.
        *   This means that there's an extra step involved in preparing the release -- "cutting" the release branch, so to speak. For this, check the [Bazel@HEAD+Downstream pipeline](https://buildkite.com/bazel/bazel-with-downstream-projects-bazel). The branch cut should happen on a green commit there; if the pipeline is persistently red, work with the Green Team to resolve it first and delay the branch cut as needed.
        *   A first release candidate should immediately be created after the release branch is created. See [create a release candidate](#create-a-release-candidate) below.
1.  After creating the branch, edit the CODEOWNERS file on that branch, replace the entire contents of the file with the line `* @your-github-username` and submit it directly.
    *   This makes sure that all PRs sent against that branch have you as a reviewer.
1.  (For minor release only) Send an email to both<EMAIL_ADDRESS>and<EMAIL_ADDRESS>announcing the next release.
    *   It should contain the text: `The Bazel X.Y.Z release branch (release-X.Y.Z [link]) is open for business. Please send cherry-pick PRs against this branch if you'd like your change to be in X.Y.Z. Please follow the release tracking issue [link] for updates.`
1.  Meanwhile, begin the [internal approval process](http://go/bazel-internal-launch-checklist), too.
    *   Note that certain steps in the internal approval process require at least preliminary release notes, so those steps should usually wait until the first release candidate is pushed and the release notes have taken vague shape.
    *   Please make sure the Eng. team review status is explicit in release notes/bazel release announcement doc(s), and ensure the Eng. team should approve the release note before creating the launch review issue.
## Maintaining the release

While the release is active, you should make sure to do the following:

*   Monitor [the "potential release blocker" label](https://github.com/bazelbuild/bazel/issues?q=label%3A%22potential+release+blocker%22).
    *   These are issues or PRs that community members have proposed to be fixed/included in the next release. Check each of these and decide whether they should be release blockers; if so, add a comment with the text `@bazel-io fork X.Y.Z` and a copy of the issue will be added to the "X.Y.Z release blockers" milestone; if not, explain why in a comment, and remove the "potential release blocker" label.
*   For cherry-picks (specifically for minor and patch releases),
    *   If a Bazel team member has proposed the fixes, then proceed with the cherry-pick and merge it.
    *   If a Bazel team member authors a commit and a community member asks to cherry-pick, then confirm with the author before cherry-picking the PR to make sure this change is safe to merge.
    *   If a community member author a commit and asks to cherry-pick, then confirm with the reviewer before cherry-picking the PR to make sure that the change is safe to merge.
*   Review any PRs sent to the release branch and merge them as necessary.
    *   Make sure to close any related release blocker issues after merging the PRs; merging PRs into non-main branches does *not* automatically close related issues (see [GitHub docs](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)).
*   When enough PRs have been cherry-picked and the release is nearing a ready state, create a release candidate (see [below](#create-a-release-candidate)).
    *   When a few days pass and no more release blockers show up, push the candidate as the release. Otherwise, rinse and repeat the steps above.
*   Keep the task list in the release tracking issue updated and check boxes as you follow the release process.
    *   In particular, try and keep the estimated release date updated.

## Create a release candidate

1.  Create a branch (via the GitHub UI or via the command line) named `release-X.Y.ZrcN` at the appropriate commit.
    *   This branch is essentially used as a tag (i.e. no further commits should happen on this branch). All cherry-pick commits should continue to go into the release branch (i.e. `release-X.Y.Z`, without the `rcN` part).

1.  Check BuildKite results at https://buildkite.com/bazel-trusted/bazel-release. You should
    see the `release-X.Y.ZrcN` branch here and a new build running for
    your release. Building Patch Release for old bazel version, create a new build and in 'Option' choose Environment Variable as USE_BAZEL_VERSION=X.Y.(Z-1) i.e previous version.
    See example:
    *   Go to https://buildkite.com/bazel-trusted/bazel-release
    *   Click "New Build", then fill in the fields like this:
        *   Message: Release-4.2.3rc1 (Or any message you like)
        *   Commit: HEAD
        *   Branch: release-4.2.3rc1
        *   Option: USE_BAZEL_VERSION=4.2.2
1.  Check the postsubmit test run for the release branch to ensure that all
    tests on all platforms pass with the version you're about to release.

    *   Go to https://buildkite.com/bazel/bazel-bazel and find the
        `release-X.Y.ZrcN` branch in the list. A build should
        automatically run. Make sure that it passes.

1.  When it all looks good, go back to the job in the
    [release pipeline](https://buildkite.com/bazel-trusted/bazel-release/builds),
    click "Deploy release artifacts" for the deployment step.

    *   This will upload the release candidate binaries to GitHub and our
        apt-get repository. The github link is probably of the form:
        https://releases.bazel.build/3.6.0/rc1/index.html

1.  If that worked, click on the "Generate announcement mail text" step to unblock it.
    If it's the first release candidate, prepare the release announcement (see
    next section).

1.  Copy & paste the generated text into a new e-mail and send it. If you're
    creating a new release candidate, reply to the previous e-mail to keep all
    the information in one thread.
    *   The first line is the recipient address.
    *   The second line is the subject.
    *   The rest is the body of the message.
    *   Replace the generated notes with a link to the release announcement draft.
       `https://docs.google.com/document/d/1wDvulLlj4NAlPZamdlEVFORks3YXJonCjyuQMUQEmB0/view`

1.  Trigger a new pipeline in BuildKite to test the release candidate with all the downstream projects.
    *   Go to https://buildkite.com/bazel/bazel-with-downstream-projects-bazel
    *   Click "New Build", then fill in the fields like this:
        *   Message: Test Release-3.0.0rc2 (Or any message you like)
        *   Commit: HEAD
        *   Branch: release-3.0.0rc2

1.  Look for failing projects in red.
    *   Compare the results with the latest Bazel release:
        *   Jobs built with the latest Bazel:
            https://buildkite.com/bazel?team=bazel
        *   Jobs built with release candidate: e.g.
            https://buildkite.com/bazel/bazel-with-downstream-projects-bazel/builds/287

        If a project is failing with release candidate but not with the latest
        Bazel release, then there's probably a regression in the candidate. Ask
        the Bazel sheriff if the problem is already noticed. If not, find out
        the culprit, file an issue at
        https://github.com/bazelbuild/bazel/issues and mark it as release
        blocker.

        If a project is failing with both release candidate and the latest Bazel
        release, it could be a breakage from the project itself. Go through the
        build history (eg.
        [TensorFlow_serving](https://buildkite.com/bazel/tensorflow-serving/builds?page=2))
        to confirm this, then file an issue to their owners.

    *   File bugs (**TODO: how to find the owner/project link?**)

1.  Once issues are fixed, create a new candidate with the relevant cherry-picks.

## Release announcement

The release manager is responsible for the [draft release
announcement](https://docs.google.com/document/d/1wDvulLlj4NAlPZamdlEVFORks3YXJonCjyuQMUQEmB0/edit).

Once the first candidate is available:

1.  Open the doc, create a new section with your release number, add a link to
    the GitHub issue.
1.  Copy & paste the generated text from the "Generate Announcement" step.
1.  Reorganize the notes per category (C++, Java, etc.).
1.  For each category, add a comment and assign it to the corresponding
    [team contact](https://www.bazel.build/maintainers-guide.html#team-labels):
    "+person for review (see guidelines at the top of the doc)".
1.  Send an email to [bazel-dev](https://groups.google.com/forum/#!forum/bazel-dev) for
    additional reviews.
1.  Assign a comment to "+[aiuto@google.com](mailto:aiuto@google.com)"
    and "+[daroberts@google.com](mailto:daroberts@google.com)"
    for a global review.

After a few days of iteration:

1.  Make sure all comments have been resolved, and the text follows the
    guidelines (see "How to review the notes?" in the document).
1.  Send a pull request to [bazel-blog](https://github.com/bazelbuild/bazel-blog/).

## Release requirements

1.  The release announcement must be ready (the pull request has been reviewed).
1.  Verify that the [conditions outlined in our policy](https://bazel.build/support.html#policy) **all apply**. As of
    May 2019 those were the following, but _double check_ that they have not changed since then.
    1.  at least **1 week passed since you pushed RC1**, and
    1.  at least **2 business days passed since you pushed the last RC**, and
    1.  there are no more release blocking issues.

## Push a release

1.  **Push the final release (do not cancel midway)** by running the following commands in a Bazel git repo on a Linux machine:

    ```bash
    git fetch origin release-X.Y.ZrcN
    git checkout release-X.Y.ZrcN
    scripts/release/release.sh release
    ```

    **Warning**: If this process is interrupted for any reason, please check the following before running:
      * Both `release-X.Y.ZrcN` and `master` branch are restored to the previous clean state (without addtional release commits).
      * Release tag is deleted locally (`git tag -d X.Y.Z`), otherwise rerun will cause an error that complains the tag already exists.

1.  A CI job is uploading the release artifacts to GitHub. Look for the release
    workflow on https://buildkite.com/bazel-trusted/bazel-release/. Unblock the steps by clicking "Deploy release artifacts". Subsequently you should
    see the updated version in Github.

1.  Ensure all binaries were uploaded to GitHub properly.
    1.  **Why?** Sometimes binaries are uploaded incorrectly.
    1.  **How?** Go to the [GH releases page](https://github.com/bazelbuild/bazel/releases),
        click "Edit", see if there's a red warning sign next to any binary. You
        need to manually upload those; get them from
        `https://storage.googleapis.com/bazel/$RELEASE_NUMBER/release/index.html`.
1.  Update the release bug:
    1.  State the fact that you pushed the release
    1.  Ask the package maintainers to update the package definitions:
        [@vbatts](https://github.com/vbatts) [@petemounce](https://github.com/petemounce) [@excitoon](https://github.com/excitoon)
    1.  Example: [https://github.com/bazelbuild/bazel/issues/3773#issuecomment-352692144]
1.  Publish versioned documentation (For major and minor releases only)
    1.  Fetch the git tag for the release: `git fetch --tags`
    1.  Do a checkout to that tag: `git checkout X.Y.Z`
        1. You should see this message:

        ```
        $ git checkout X.Y.Z
        Note: checking out 'X.Y.Z'.

        You are in 'detached HEAD' state. You can look around, make experimental
        changes and commit them, and you can discard any commits you make in this
        state without impacting any branches by performing another checkout.

        If you want to create a new branch to retain commits you create, you may
        do so (now or later) by using -b with the checkout command again. Example:

        git checkout -b <new-branch-name>

        HEAD is now at defd737761 Release X.Y.Z (yyyy-mm-dd)
        ```
    1.  [Install `gsutil`](https://cloud.google.com/storage/docs/gsutil_install)
        and ensure you have access to the `bazel-public` GCP project.
    1.  Run `scripts/docs/generate_versioned_docs.sh`. If you get interrupted,
        it is safe to re-run the script. This script will build the web assets
        for the documentation, generate a tarball from them, and push the
        tarball to Google Cloud Storage.
        * The script will fail to run if you're not in a git checkout of a
          release.
        * If the tarball has already been pushed to GCS, this script will not
          overwrite the existing tarball.
    1.  Ping @fweikert to update the documentation site.

1.  Merge the blog post pull request. (For major and minor releases only)
    1.  Make sure you update the date in your post (and the path) to reflect when
    it is actually published.
    1.  **Note:** The blog sometimes takes time to update the homepage, so use
    the full path to your post to check that it is live.
1.  For major and minor releases, update the release page to replace the generated notes with a link to the blog post. For patch release, update the           release notes without a blog post link - see example: https://github.com/bazelbuild/bazel/releases/tag/5.3.1
1.  Close the release-tracking bug.

### Updating Google's internal mirror

Please ping @meteorcloudy to copy the release binary to their internal mirror.

### Updating the Homebrew recipe

[Homebrew](http://brew.sh/index.html) is a package manager for OS X. This
section assumes that you are on a Mac OS machine with homebrew installed.

To update the `bazel` recipe on Homebrew, you can send a pull request to
https://github.com/Homebrew/homebrew-core/blob/master/Formula/bazel.rb.

Example: https://github.com/Homebrew/homebrew-core/pull/57966

However, usually the Homebrew community takes care of this reasonably
quickly, so feel free to skip this step, if you aren't familiar with it.

### Updating the Chocolatey package

As of November 2016, this is done by an external contributor,
[@petemounce](https://github.com/petemounce) on GitHub. Ping him when there's a
new release coming out.

### Updating the Scoop pakage

As of February 2019, this is done by an external contributor,
[@excitoon](https://github.com/excitoon) on GitHub. [Ping him](http://telegram.me/excitoon) when there's a
new release coming out.

### Updating the Fedora package

This is done by an external contributor, [@vbatts](https://github.com/vbatts) on
GitHub. Ping him when there's a new release coming out.

### Push new docker image

Follow the [instructions](../bazel/oci/README.md) to push new docker image for the new release, ping [@meteorcloudy](https://github.com/meteorcloudy) for help.

repository: libertyy/continuous-integration

repo_name: libertyy/continuous-integration


text:
# pyEZmock

![GitHub](https://img.shields.io/github/license/cheng-zhao/pyEZmock.svg)

## Introduction

This is a python wrapper of the *Effective Zel'dovich approximation mock generator*[\[1\]](#ref1) (EZmock), as well as the clustering measurement codes [powspec](https://github.com/cheng-zhao/powspec), [FCFC](https://github.com/cheng-zhao/FCFC), and bispec[*](#note1).

It creates bash scripts for running EZmocks and measuring clustering statistics, and submits them to the [Slurm workload manager](https://slurm.schedmd.com/documentation.html) if necessary. It is designed for the *National Energy Research Scientific Computing Center* ([NERSC](https://www.nersc.gov/)), but can be used in any computing environment, provided the dependencies.

This package is written by Cheng Zhao (赵成), and is distributed under the [MIT license](LICENSE.txt).

If you use this tool in research that results in publications, please cite the following papers:

> Chuang et al., 2015, [MNRAS, 446, 2621](https://ui.adsabs.harvard.edu/abs/2015MNRAS.446.2621C/abstract)

> Zhao et al. 2020, [arXiv:2007.08997](https://ui.adsabs.harvard.edu/abs/2020arXiv200708997Z/abstract)

*: to be appeared on github soon.

## Dependencies

The dependencies of this package are as follows:

-   [Python3](https://www.python.org/)  (>= 3.7)
-   [NumPy](https://numpy.org/) \[*optional*\]
-   [Matplotlib](https://matplotlib.org/) \[*optional*\]
-   EZmock[**](#note2)
-   [powspec](https://github.com/cheng-zhao/powspec) \[*optional*\]
-   [FCFC](https://github.com/cheng-zhao/FCFC) \[*optional*\]
-   bispec[***](#note2) \[*optional*\]

They are all available on NERSC, and linked to this package by default.

**: can be obtained on request to Chia-Hsun Chuang (chuangch \[at\] stanford.edu).

***: can be obtained on request to [Cheng Zhao](mailto:zhaocheng03@gmail.com).

## Usage

Please refer to the example [notebook](example_pyez.ipynb).

## Acknowledgements

This package is inspired by [Tony Zhang's work](https://github.com/neutrinonerd3333/ezmock), and I thank Dr. Chia-Hsun Chuang for his supports and suggestions.

## References

\[1\] Chuang, Kitaura, Prada, Zhao, Yepes, 2015, [EZmocks: extending the Zel'dovich approximation to generate mock galaxy catalogues with accurate clustering statistics](https://doi.org/10.1093/mnras/stu2301), *MNRAS*, 446(3):2621–2628

\[2\] Zhao, et al. (*eBOSS Collaboration*), 2020, [The Completed SDSS-IV extended Baryon Oscillation Spectroscopic Survey: one thousand multi-tracer mock catalogues with redshift evolution and systematics for galaxies and quasars of the final data release](https://arxiv.org/abs/2007.08997), *arXiv e-prints*, 2007.08997

repository: Jiaxi-Yu/pyEZmock

repo_name: Jiaxi-Yu/pyEZmock


text:
---
title: Rich Text Editor Essentials
seo-title: Rich Text Editor Essentials
description: Rich text Editor feature overview
seo-description: Rich text Editor feature overview
uuid: f96015cc-114b-431a-a5ba-dc195c2a0b83
contentOwner: msm-service
products: SG_EXPERIENCEMANAGER/6.5/COMMUNITIES
topic-tags: developing
content-type: reference
discoiquuid: 0225a543-0fad-488b-8b0b-8b3512d44fbe
exl-id: 821e32f4-da8d-4bbb-936a-0844b8a24cdd
---
# Rich Text Editor Essentials {#rich-text-editor-essentials}

## Overview {#overview}

A Rich Text Editor (RTE) provides the ability to enter text with markup.

For Communities components, while similar to the [rich text editor in the author environment](../../help/sites-authoring/rich-text-editor.md), it affects text entered in the publish environment.

![rich-text-editor](assets/rich-text-editor.png)

## Enabling Rich Text Editor {#enabling-rich-text-editor}

Communities components that allow user generated content (UGC) can be enabled to allow RTE. Depending on whether the component was added to a page or included within a [function](functions.md), RTE may or may not be enabled by default.

If not enabled, simply enter [author edit mode](sites-console.md#authoring-site-content), select the component for edit, and select the `Rich Text Editor` checkbox.

RTE is available for the following Communities components:

* [Blog](blog-feature.md)
* [Calendar](calendar.md)
* [Comments](comments.md)
* [Filelibrary](file-library.md)
* [Forum](forum.md)
* [Messaging](configure-messaging.md)
* [QnA](working-with-qna.md)
* [Reviews](reviews.md)

## Customization {#customization}

Customization of the rich text editor is possible as the implementation is based on [CKEditor](https://www.ckeditor.com/).

The current configuration for Communities components is in the `cq.social.  scf   clientlib`, located in the repository at

`/libs/clientlibs/social/commons/scf/ckrte.js`

Modifying the cq.social.scf clientlib is not recommended as future upgrades may override any edits.

### Example Customization: Inline Links {#example-customization-inline-links}

Due to security concerns, the hyperlink options are not included in the set of rich text icons presented to members by default. The ability for mischief is extensive when hrefs are allowed in UGC.

To add the hyperlink options to the toolbar:

* Add a toolbar named " `links`"
  * `{ name: 'links', items: [ 'Link','Unlink','Anchor' ] }`
* Select **[!UICONTROL Save All]**

#### /libs/clientlibs/social/commons/scf/ckrte.js {#libs-clientlibs-social-commons-scf-ckrte-js}

```
CKRte.prototype.config = {
    toolbar: [
        { name: "basicstyles",
           items: ["Bold", "Italic", "Underline", "NumberedList", "BulletedList", "Outdent", "Indent", "JustifyLeft", "JustifyCenter", "JustifyRight", "JustifyBlock", "TextColor"]
        },
        { name: 'links',
           items: [ 'Link','Unlink','Anchor' ]
        }
    ],
    autoParagraph: false,
    autoUpdateElement: false,
    removePlugins: "elementspath",
    resize_enabled: false
};
```

gha_language: Groovy


text:
# gistrb - A command-line utility to post files directly as Gists on GitHub.com
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fcameronbroe%2Fgistrb.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fcameronbroe%2Fgistrb?ref=badge_shield)

### Description:
This is a utility to easily post local source files you have on GitHub Gists. It
supports uploading multi-file Gists, authenticated Gists, anonymous Gists, and
declaring the Gists as private or public. You can also attach descriptions to the Gist you post.

## Usage:

```shell
gistrb [opts] source_file source_file2 ...
```

`gistrb` also supports input from STDIN. If `gistrb` is invoked with no files and nothing piped in, then it will wait
on the terminal for input from STDIN until it reads an EOF character. An EOF character can be inserted on the terminal using Ctrl+D.

Any files in the Gist from STDIN will be labelled as "STDIN".

```shell
$ cat foo.txt | gistrb [opts] source_file # Reads foo.txt from piped STDIN and source_file as a file.
$ gistrb [opts] # Waits until it reads Ctrl+D and processes that data as STDIN
```

## Options:
Option                                 | Description
-------------------------------------- | -----------
 -u | --user                      | Post the Gist as currently signed in user
 -s | --sign-in                   | Sign into the utility using your GitHub account
 --sign-out                            | Sign out of the utility
 -p | --public                    | Post the Gist as public (it posts as private by default)
 -d [DESC] | --description [DESC] | Use [DESC] as the description for the Gist
 -c | --clipboard                 | Automatically put the created Gist URL into your clipboard (beta)
 -n | --netrc                     | Utilize .netrc file for storing/retrieving authorization token

## Installation:
Using RubyGems, simply run this command:
`gem install gistrb`

## Requirements:
If on Linux, you need to have xclip installed for clipboard support

To install this on Ubuntu-based distributions, run the following command.
```shell
sudo apt-get install xclip
```

## License
MIT License

Copyright © 2018 Cameron Roe

[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fcameronbroe%2Fgistrb.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fcameronbroe%2Fgistrb?ref=badge_large)

repository: fossabot/gistrb

repo_name: fossabot/gistrb


text:
# Word Count

Write a program that given a phrase can count the occurrences of each word in that phrase.

For example for the input `"olly olly in come free"`

```plain
olly: 2
in: 1
come: 1
free: 1
```

### Submitting Exercises

Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.

For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.

For more detailed information about running tests, code style and linting,
please see the [help page](http://exercism.io/languages/python).

## Source

This is a classic toy problem, but we were reminded of it by seeing it in the Go Tour.

## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.


text:
<!--
[![Build Status](https://travis-ci.org/dhakehurst/net.akehurst.language.svg?branch=master)](https://travisci.org/dhakehurst/net.akehurst.language)
-->
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/net.akehurst.language/agl-processor/badge.svg?gav=true)](https://maven-badges.herokuapp.com/maven-central/net.akehurst.language/agl-processor)
![npm](https://img.shields.io/npm/v/net.akehurst.language-agl-processor)
[![Generic badge](https://img.shields.io/badge/Kotlin-1.5.30-green)](https://kotlinlang.org/)

# AGL: A Grammar Language (or maybe Akehurst Grammar Language!)

Generic Language (DSL) support for kotlin multiplatform (parser, syntax-analyser, formatter, processor, etc)

There are many parser technologies, frameworks, generators, libraries
that already exist. When I first started this one in about 2007 there was none that
met all the requirements that I have. It has taken me several years (too many) to finally
reach the stage where I am happy to publish it. (mostly because it was a home project and not
worked on very frequently until the last couple of years, 2017/2018).

My Requirements:

 - Simple grammar for defining a language with no restrictions
 -- i.e. should support left & right recursive rules,
 - Useable in Java and Javascript (other platforms/languages a bonus but not essential)
 - No need to worry about keyword/identifier clashes
 - Interpreted at runtime, i.e. no generate parser step.
 - Supports families of languages, i.e. grammar composition/extension
 -

# Other
 - [Editor Integration and Demo](https://github.com/dhakehurst/net.akehurst.language.editor)

# Articles

 - [Creating a custom Domain Specific Language for text input validation](https://medium.com/javascript-in-plain-english/agl-your-dsl-in-the-web-c9f54595691b)
 -<EMAIL_ADDRESS>
# TODO

lots:
 - performance improvements
 - PT is not always what one expects

# Build
There are currently a number of failing tests, these indicate things to be fixed, and desired performance improvements.
To build locally the latest version, use `assemble` or `publishToMavenLocal`.
```
> cd net.akehurst.language
> ./gradlew clean assemble
```

gha_language: Kotlin


text:
# TSL2561_DHT22_RTC_Datalogger
Luminosity, Humidity and Temperature datalogger

## Changelog

##### Version 1.3
* rewrite creation of file name as YYYYDDMMHHIISS.csv
* minor changes

##### Version 1.2
* use of RealTimeClockDS1307.h https://github.com/davidhbrown/RealTimeClockDS1307
* code cleanup

##### Version 1.1
* initial version


text:
# *Free Social Benefit Coins
A Blockchain, Crypto, Sharable Prosperity, Giftivism based Airdrop idea by Gregory Kennedy.
https://medium.com/@gregorykennedysalemi/part-1-blockchain-crypto-sharable-prosperity-gift-tivism-based-airdrop-13913f1cc78f

repository: bendlas/Official-SBC-SocialBenefitCoin

repo_name: bendlas/Official-SBC-SocialBenefitCoin


text:
---
layout: post
title: "Clojure and OO part 2   defrecord"
description: "defrecord"
category: Clojure
tags: [Clojure, OO, defrecord]
---
{% include JB/setup %}

In the [last post](http://lorettahe.github.io/clojure/2015/07/21/clojure-and-oo-part-1/), I talked about how to create interfaces/protocols in Clojure with *definterface* and *defprotocol*, and from this post on, I will start talking about various ways in Clojure to implement them.

And I will start with the simpler ones, such as *defrecord*.

**What is it?**

One can use defrecord to make a solid class implementing one or more interface/protocols in Clojure. As the name suggests, it's mainly used for defining *record types*, as in types that are normally used to store data.

Let's look at an example:

{% highlight clojure %}
(defrecord Cat [name age breed])
{% endhighlight %}

Uh...that's a bit simple you say? Yes, you've got it! It's supposed to be simple!

It defines a java class that have three fields in it - name, age and address. That's it. Piece of cake. Now here's an important bit: **All the classes generated by defrecord implement the IPersistentMap interface.** And what does that mean? It means **you can treat these fields like how you normally access the corresponding value of a keyword in a map in Clojure**.

Let's make a new instance of our shiny new Cat class:

{% highlight clojure %}
(def sherlock (->Cat "Sherlock" 3 "Russian Blue"))
{% endhighlight %}

"Wait wait wait, what is **->Cat**?? I never defined such a thing!" I can already hear our keen readers interrupting me here. Well, you did, and you just didn't know you did. You did back when you called that defrecord in our first code excerpt. Clojure will automatically define this handy function for you to use to create new instances of your record types. (And yes, before you ask, Sherlock is one of my endearing cats at home.)

And Clojure has another trick up its sleeve - there is also another defined function named **map->Cat**. The name should already tell you what it does - it turns a map into an instance of our new Cat type.

Here is **map->Cat** doing the same thing as **->Cat**:

{% highlight clojure %}
(def sherlock (map->Cat {:name "Sherlock" :age 3 :breed "Russian Blue"}))
{% endhighlight %}

It's a bit more verbose, but it's a lot clearer what you are passing to each field, basically the difference between ordered parameters and named parameters. You can take your own pick, I personally prefer named parameters.

OK. Now we have our cat Sherlock. How do you get its age again? As I said above, you can treat these record type instances like how you normally treat maps in Clojure:

{% highlight clojure %}
(println (:age sherlock))
; We might want to update his age when he grows older...
(def older-sherlock (update sherlock :age inc))
{% endhighlight %}

Again, very simple...

But, is that all defrecord can do? No, my friend. These record types can also implement interfaces, remember? They **can't have their own methods**, but they can, and have to implement all the methods they inherit from various interfaces.

Let's make the famous Animal interface and a fun LaserChaser interface:

{% highlight clojure %}
(defprotocol Animal
  (make-noise [this] "Make the animal noise"))

(defprotocol LaserChaser
  (chase-laser [this] "Chase the laser!"))
{% endhighlight %}

Now let's have an upgraded Cat record type that implements these two interfaces.

{% highlight clojure %}
(defrecord UpgradedCat
  [cat-name age breed]
  Animal
  (make-noise [this] (println "meow"))
  LaserChaser
  (chase-laser [this] (println cat-name "made a pounce for the laser dot!")))

(def upgraded-sherlock (map->UpgradedCat {:cat-name "Sherlock" :age 3 :breed "Russian Blue"}))
(make-noise upgraded-sherlock)
(chase-laser upgraded-sherlock)
{% endhighlight %}

Now remember, you can get record types to implement any interfaces, not just Clojure defined ones.

And I think that's about it for **defrecord**. Oh, and one last thing, you **cannot use defrecord to extend solid classes**. We will eventually get around to that, probably towards the end of this series. For now, it's wrap-up time! Go watch TV or something, or hopefully you may have been excited about this enough to go write some Clojure!

P.S. [defrecord @ ClojureDocs](https://clojuredocs.org/clojure.core/defrecord)


text:
# NKSlideScreensTemplate

<!-- [![CI Status](https://img.shields.io/travis/nkopilovskii/NKSlideScreensTemplate.svg?style=flat)](https://travis-ci.org/nkopilovskii/NKSlideScreensTemplate) -->
[![Version](https://img.shields.io/cocoapods/v/NKSlideScreensTemplate.svg?style=flat)](https://cocoapods.org/pods/NKSlideScreensTemplate)
[![License](https://img.shields.io/cocoapods/l/NKSlideScreensTemplate.svg?style=flat&color=yellow)](https://cocoapods.org/pods/NKSlideScreensTemplate)
[![Platform](https://img.shields.io/cocoapods/p/NKSlideScreensTemplate.svg?style=flat&color=black)](https://cocoapods.org/pods/NKSlideScreensTemplate)

## Description
The solution is a template with the implementation of the basic methods of configuration and  management of UIPageViewController.

The solution is designed for multi-level architectures, as it allows to distribute the code into the corresponding layers of the module.

## Example

1. Create `ViewController` class with parent `NKSlidesViewController` class

```swift
  class ViewController: NKSlidesViewController { }
```

2. Override properties `source: NKSlidesSource` and  `container: UIView` for the ability to configure slide pages
```swift
  class ViewController: NKSlidesViewController {

    override var source: NKSlidesSource? { return ... }

    override var container: UIView { return ... }

  }
```

3. Create type custom supporting `NKSlidesSource` protocol (*if you use MVC you can implement protocol in ViewController class*)
```swift
  class Presenter: NKSlidesSource {

    var viewer: NKSlideScreenViewable?

    var initialPage: UIViewController {
      //return UIViewController instance which must to be shown first on screen's display
      return ...
    }

    func didPresent(_ page: UIViewController?) {
      //any action after page was presented
    }

    func page(after viewController: UIViewController) ->  UIViewController? {
      //return UIViewController instance which must to be shown after passed page
      return ...
    }

    func page(before viewController: UIViewController) -> UIViewController? {
      //return UIViewController instance which must to be shown after passed page
      return ...
    }

  }
```

4. Add `Presenter` initialization to `ViewController`
```swift
class ViewController: NKSlidesViewController {

  override var source: NKSlidesSource? {
    return presenter
    // if you use MVC you can `return self`
  }

  override var container: UIView { return ... }

  lazy var presenter = Presenter(self)

}
```

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

**iOS** 10.0

**Swift** 5.0

## Installation

NKSlideScreensTemplate is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'NKSlideScreensTemplate'
```

## Author

nkopilovskii<EMAIL_ADDRESS>
## License

NKSlideScreensTemplate is available under the MIT license. See the LICENSE file for more info.

repository: nkopilovskii/NKSlideScreensTemplate

repo_name: nkopilovskii/NKSlideScreensTemplate


text:
# Joy Trigger Script

## How to Use

When loading a camera, set `calib_mode: true` in the config to enable the
functionality to save images via a trigger.

Here the images are saved in the directory set by `image_directory` under a
subfolder `calib`. The camera itself waits for an empty message to be published
to `camera/save_image` in order to trigger an image save.

The following script helps does this. In order to use the script, run:

```
rosrun joy joy_node &
python joy_trigger_node.py
```

And press `A` with an attached usb joystick to trigger an image save.


text:
# Node and Expo

## 1 Node.js

Node.js, often called node, is a JavaScript engine that executes JavaScript code from your operating system. There are two installers you can download from the [node.js download site](https://nodejs.org/en/download/): a LTS (Long Term Support) version or a current version. Please download and run the LTS installer, you should be able to run the following command:

- `node -v`: shows the current node.js verison
- `npm -v`: shows the node pacakge managerment version

[`npm`](https://docs.npmjs.com/) is JavaScript's package management system. It has two components: a world's largest software registry and a client CLI tool. As a developer, you just the `npm` CLI tool to download JS packages. Facebook develops another client CLI tool called [`yarn`](https://classic.yarnpkg.com/en/). Because React and React Native are developed by Faceboo, many React developers use `yarn` to manage JS packages. To install it and verify the installation, run the following CLI commands:

`npm install --global yarn`
`yarn -v`

Resources:

- [What is npm](https://youtu.be/ZNbFagCBlwo)

## 2 Expo

[Expo](https://docs.expo.io/) is a set of tools and services to help you develop RN apps.

Expo is a Node.js packaged that can be installed by `npm`. Run `npm i expo-cli --global` to install it as a global package thus you can run it from any project.

Run `expo --version` to verify the installation.

## 3 Expo Go App

You can use the `Expo Go` app to debug your RN apps. Check the [Expo Go document](https://docs.expo.io/get-started/installation/#2-expo-go-app-for-ios-and) to install the app in your phone if you want to debug the app from your smart phone.

## 4 Create an Expo Account

Please goto [Expo](https://expo.io/) to sign up an account. You need an account to publish your apps thus we can check them.


text:
## How to :

### Please add a file "teamBotToken.py" as below:

```python
class teamBotToken(object):
    def __init__(self):
        self.token="Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
````

repository: ccieliu/shiftclick

repo_name: ccieliu/shiftclick


text:
![network diagram](assets/img/logos/network-black-512sq-150x150.png)

# DIG 245 - Critical Web Design

Tutorials, demos, and resources for DIG 245 Critical Web Design

## Assignments, Milestones, and Sample code

- Assignments: See class assignment document
- Milestones:
	- [git-milestones](https://github.com/omundy/learn-git-milestones)
	- [html-css-milestones](https://github.com/omundy/learn-html-css-milestones)
	- [js-milestones](https://github.com/omundy/learn-js-milestones)
- Samples: [/demos](demos/)

## Tutorials, Tools, and References

### HTML & CSS

Tutorials and references from the Critical Web Design course content

- [HTML](reference-sheets/html.md), [CSS](reference-sheets/css.md), and [Javascript](reference-sheets/javascript.md) reference sheets

### Version Control and Collaboration

- DIG 245 [Git & Github Desktop slides](https://docs.google.com/presentation/d/1vtK6LoqwF4rQQZZy-ovuEgsYUwwMRXsqDVMOjAPSBt0/edit)
- [Github Cheatsheet](https://github.github.com/training-kit/downloads/github-git-cheat-sheet.pdf)
- [Github Markdown Cheatsheet](https://guides.github.com/pdfs/markdown-cheatsheet-online.pdf)

### Javascript

Tutorials and references from the Critical Web Design course content

- [Javascript](reference-sheets/javascript.md) reference sheets
- [Javascript slides](https://docs.google.com/presentation/d/1mTMY_jT3nVvrdE2JNrFNVsRBjnFFf90LhKB3W-2w3Fg/edit)
- [Intro & Technical Reference (concepts, software, etc.)](https://docs.google.com/presentation/d/1OVCMHMfB_0gYgTtv2iMK_aCktJtCSRp1aRvH3T1W0JU/edit?usp=sharing)

Technical references

* W3Schools [Javascript](https://www.w3schools.com/jsref/default.asp) reference
* [Async JavaScript, a Pocket Reference: Learn asynchronous programming in JavaScript](https://medium.com/@ajmeyghani/async-javascript-a-pocket-reference-2bb16ac40d21)
* [W3Schools: Console Object](https://www.w3schools.com/jsref/obj_console.asp)
* [Boost your JavaScript Debugging Skills With These Console Tricks](https://medium.com/better-programming/boost-your-javascript-debugging-skills-with-these-console-tricks-ab984c70298a)

Common JS problems

- [Swap images with Javascript / jQuery](https://codepen.io/owenmundy/pen/OJRWQoY)

## Frameworks, Libraries, and other Tools

### Wordpress

* [Understrap theme](https://understrap.com/) - [documentation](https://understrap.github.io/), [code](https://github.com/understrap/understrap), [demo](https://understrap.com/understrap/), and [showcase](https://github.com/understrap/understrap/issues/208)

### Leaflet Maps

* [Leaflet: Make a web map!](https://maptimeboston.github.io/leaflet-intro/)
* [Web Map Workshop](http://duspviz.mit.edu/web-map-workshop/)

### Data

* [jsonlint.com](https://jsonlint.com/) - The JSON validator
* [geojson.io](http://geojson.io/) - The missing GUI for GEOJSON files

### Graphics

* [SVGOMG](https://jakearchibald.github.io/svgomg/) - The missing GUI for SVG files
* [Coolers](https://coolors.co/) - Color scheme generator

## Setup your development environment

[topics-development-environment](topics-development-environment.md)

## Testing and Validation

### Make a bookmarklet

1. Copy a JS code sample (e.g. below...)
```
javascript:alert("hello world!")
```
2. Paste it into [this form](http://ted.mielczarek.org/code/mozilla/bookmarklet.html)
3. Change the name to something relevant, like `hello`
4. Click "Crunch"
5. Drag the bookmarklet link to your bookmark bar

### HTML and CSS validator bookmarklet
Use the code below and the above bookmarklet instructions
```javascript
var loc = document.location;
var css = window.open("http://jigsaw.w3.org/css-validator/validator?profile=css3&warning=0&uri=" + loc, "css");
var html = window.open("http://validator.w3.org/check?verbose=1&uri=" + loc, "html");
```

### Last modified bookmarklet
Use the code below and the above bookmarklet instructions
```
javascript:alert(document.lastModified)
```

### Website, Domain, and Server Tests

Website health and performance
* [Google Speed](https://developers.google.com/speed/pagespeed/insights/)
* [Pingdom](https://tools.pingdom.com/) - Check server and website performance
* [GTMetrix](https://gtmetrix.com/) - Another measurement for server and website performance
* [WebPageTest](https://www.webpagetest.org/)
* [Wordpress Checkup](https://premium.wpmudev.org/wp-checkup/)

Domain name, email, and SSL checks
* [ICANN WHOIS](https://whois.icann.org/en) - Lookup domain registration and nameservers
* [DNS Checker](https://dnschecker.org/) - Global DNS Propagation Checker
* [MX Lookup](https://mxtoolbox.com/MXLookup.aspx) - Check the health of email on your server
* [HTTP Header Checker](https://tools.keycdn.com/curl) - Analyze HTTP response headers
* [HTTP/2 Test](https://tools.keycdn.com/http2-test) - Verify HTTP/2 support
* [SSL Checker](https://www.sslshopper.com/ssl-checker.html) - Diagnose problems with your SSL certificate installation

Content, meta content, and errors
* [Google Webmaster Tools](https://www.google.com/webmasters/tools) - Check your sitemap, robots file, and 404s
* [Open Graph Checker](http://opengraphcheck.com) - Do you have meta information for the open graph?
* [Facebook Sharing Debugger](https://developers.facebook.com/tools/debug/) - Evaluate your [Open Graph](https://ogp.me/) FB sharing tags
* [Twitter Card Validator](https://cards-dev.twitter.com/validator) - Evaluate your Twitter sharing tags
* [Google Rich Results Test](https://search.google.com/test/rich-results) - To examine your [schema.org tags](https://schema.org/docs/gs.html)
* [http.cat](https://http.cat/) - An essential visual reference for HTTP response codes


text:
# Deploy & test saga with Kubernetes

You can now play with saga under Kubernetes!

The demos' Kubernetes resources are splitted into 3 categories:

- **base**: The base resources that all demos needs under `base/` folder, including the `alpha-server,`the `postgresql` database, and a `jmeter-collector` for [load test](https://github.com/apache/servicecomb-saga/blob/master/docs/load_test.md).
- **demos**: The resources that each demo will consume, stored in the folder named with `xxx-demo/`
- **tests**: A [jmeter](https://jmeter.apache.org/) deployment is provided for each demo under the demo's `test/` folder, there is also a [Kubernetes configmap](http://kubernetes-v1-4.github.io/docs/user-guide/configmap/) where you can change and apply the jmeter test plans. So you can change the plan at any time and pull up the jmeter deployment to test the demos.

## Get started

All the Kubernetes objects will be deployed in the `servicecomb` namespace, so make sure it is there with the command:

```bash
$ kubectl create namespace servicecomb
namespace "servicecomb" created
```

Let's take the `spring-demo` as the example, apply the base and demo resources:

```bash
$ kubectl apply -f ./base
service "alpha-server" created
deployment "alphaserver" created
service "postgresql" created
deployment "database" created
service "jmeter-collector" created
deployment "jmeter-collector" created

$ kubectl apply -f ./spring-demo
service "booking" created
deployment "booking" created
service "car" created
deployment "car" created
service "hotel" created
deployment "hotel" created

```

Make sure all the services in the demo are up and running:

```bash
$ kubectl get pods -n servicecomb
NAME                           READY     STATUS    RESTARTS   AGE
alphaserver-6cb48898fc-tlqtb   1/1       Running   0          1d
booking-666c8f4dbb-k5glt       1/1       Running   0          4h
car-975d666f8-prs9p            1/1       Running   0          1d
database-796fc68b98-mhz8n      1/1       Running   0          1d
hotel-768b59dfcd-gc7sn         1/1       Running   0          1d
```

Then you can test the demo with jmeter, modify the configmap according to your test plan, then apply the test service to Kubernetes api server:

```bash
$ vim ./spring-demo/test/jmeter.configmap.yaml
$ # edit the file as you wish, mind the identation of yamls
$ kubectl apply -f ./spring-demo/test/
configmap "springdemo-jmeter-script" created
deployment "spring-demo-jmeter" created

$ kubectl get pods -n servicecomb | grep jmeter
jmeter-collector-75c4c96dbb-2bjtc     1/1       Running   0          47s
spring-demo-jmeter-6cfb679f58-sckkx   1/1       Running   0          12s
```

The jmeter deployment will keep testing the demo and generate the test result. After each test, the result and its corresponding dashboard will be uploaded to the jmeter-collector service, which provides a simple web page to browser the test outputs. So make sure you config the jmeter-collector to be accessible, like a [NodePort](https://kubernetes.io/docs/concepts/services-networking/service/#nodeport) in a private cluster or [LoadBalancer](https://kubernetes.io/docs/concepts/services-networking/#loadbalancer) in a public cloud service.

repository: shawnwardgithub/servicecomb-pack

repo_name: shawnwardgithub/servicecomb-pack


text:
# LSTS <img src="https://pacha.dev/LSTS/hexicon.svg" width=150 align="right" alt="sticker"/>

<!-- badges: start -->
[![R build status](https://github.com/pachamaltese/LSTS/workflows/R-CMD-check/badge.svg)](https://github.com/pachamaltese/LSTS/actions?workflow=R-CMD-check)
[![Codecov test coverage](https://codecov.io/gh/pachamaltese/LSTS/branch/master/graph/badge.svg)](https://codecov.io/gh/pachamaltese/LSTS?branch=master)
[![Lifecycle: stable](https://img.shields.io/badge/lifecycle-stable-brightgreen.svg)](https://lifecycle.r-lib.org/articles/stages.html#stable)
<!-- badges: end -->

## Description

A set of functions that allows stationary analysis and locally stationary time series analysis.

## Installation

You can install the released version of LSTS from Github with:

``` r
remotes::install_github("pachamaltese/LSTS")
```

## Code of Conduct

Please note that the LSTS project is released with a [Contributor Code of Conduct](https://contributor-covenant.org/version/2/0/CODE_OF_CONDUCT.html). By contributing to this project, you agree to abide by its terms.

repository: pachadotdev/LSTS

repo_name: pachadotdev/LSTS


text:
# CSS NOTES

## Random Bits

- The `transition: ` property goes on the original object not, for example, the `:hover` selector
- Only apply transitions to `transform` and `opacity` for performance reasons
- `backface-visibility: hidden;` is a bugfix for flash or small jump at end of transitions
- rem units are relative to the root font-size. So if you set the font at 1.5 rem and the root font-size is 10px, then the font is shown at 15px.
- *em* and *rem* units are based on font sizes which are useful for building responsive sites

## How CSS "Cascades"

The "Cascading" in the name, Cascading Style Sheets comes from the ways in which browsers read code and determine which styles to apply to an element.

Usually, an element has many styles applied to it. For example, an `<a>` element likely has a default style, a universal style, and a more specific style when the `<a>` appears in a `<button>` or in a `<nav>`

The browser prioritizes based on the following from top to bottom:

1. **Importance**
   *USER is you or your browser*
   *AUTHOR is the code sent from the server*
   1. User !important
   2. Author !important
   3. Author declarations
   4. User declarations
   5. Default browser declarations
2. **Specificity** (Check for most applicable styles of each type, if tied go to next)
   1. Inline styles
   2. IDs
   3. Classes
   4. Elements and pseudo-elements
3. **Source Order** - Last style in code. Can be affected by where a selector is in a `.css` file or the order in which the files are loaded

## How CSS Values are Processed

- When a property has different declared values, the cascade determines which value is used
- Every property has a value, even if nothing is declared or inherited. The default, when no value is declared or inherited, is the initial value
- Everything is converted to pixels at render
- root font-size (usually 16px) is set by USER

### Relative Units

- **% units** are based on the parent elements calculated value
- **Fonts**
  - **em** *for font* - based on parent's font-size
  - **em** *for length* - based on the current element's font-size
  - **rem** - always uses the root font size as a refernce (for length or font-size)
- **Viewport Units**
  - **vh** - 1% of viewport height
  - **vw** - 1% of viewport width

### Inheritance

A way of propegating property values from parent elements to their children. Designed to make code more maintainable and **should be used whenever possible**.

Not all properties are inherated, need to check the specifications of each property.

Any cascaded value (value assigned with CSS selector) takes precendence over inherated values.

The computed value is inherited, not the declared value. For example, if a parent element has the property: `line-height: 150%`, 150% is **not** passed, instead the value that 150% is computed to be is passed.

Properties related to text are generally inherated, but borders, margins, and padding are generally not -- that would be annoying.

Can use `inherit` keyword to force inheritence of a specific property. This is often used in lieu of universal selectors because universal selectors might mess up plugins or external style sheets. Ex:
```css
*,
*::before,
*::after {
  /* Forces inheritance */
  box-sizing: inherit;
}

body {
  /* Sets box sizing which is inherated by all children recursively */
  box-sizing: border-box;
}
```

### Converting px to rem

#### Why use rem?

By using rem units, we create an easy way to change the size of everything using the global font-size. This is really handy for media queries and adjusting for mobile. Also, rescales everything nicely when the user zooms in with the browser.

Since `rem` is based on the root font-size in the html selector, setting that to 10px makes it easy to convert anything from px to rem. Just divide any pixel measurement by 10. But, setting the default font-size as a pixel value is a **bad idea** because it overrides users' browsers settings. People with bad vision will often set the default font-size to be larger, so you want to use a % value here. Setting the font-size to 100% will make the default size 100% of the user's browser setting. So, setting this at 62.5% converts a common 16px default font-size to a 10px size. This % approach still allows the user to "zoom" in on the page.

**rems are not supported below IE9**

<<<<<<< HEAD
## Website Rendering: The Visual Formatting Model
=======
### Website Rendering: The Visual Formatting Model
>>>>>>> 8aade837692441219535e3129c0bd5f804213b2a

An algorithm that calculates boxes and determines the layout of these boxex for each element in the render tree, in order to determine the final layout of the page.

Takes into account:

- Dimensions of boxes: box model
- Box type: inline, block...
- Positioning scheme: floats, positioning
- Stacking Contents
- Other elements of the render tree
- Viewport size, image dimensions

### The Box Model

Each and every element on the web page can be scene as a rectangular box with width, height, padding, border, and margin. But, these are optional. A border, for example, is not required.

The area outside of the content area but inside the border is known as the padding. Background-color and Background-image do cover the padding areas.

Total width includes the border-left, padding-left, defined width, padding-rigth, border-right.

Using `box-sizing: border-box` redefines the width and height to include everything but the margin

### Box Types

The box type is defined by the display property. Ex: `display: flex` or `display: inline-block`. All elements have default properties. `block` is usually the default display property.

#### Block-Level Boxes

- Take up 100% of the parent's width
- Vertical, one after another
- Box-model applies as described above

#### Inline

- Content distributed in lines
- Occupies only content's space
- No line-breaks
- No heights and widths -- can't use these properties here
- Paddings and margins on horizontal

#### Inline-block

- Mix of block and inline
- Occupy only contents space (like inline)
- No line breaks (like inline)
- Box-model applies as show (like block-level)

### Positioning Schemes

#### Normal Flow

- Default scheme when not floated and no absolute positioned. Still used with `position: relative`
- Elements laid out according to their source order

#### Floats

- Removed from the normal flow
- Text and inline elements wrap around the floated element
- The container will not adjust its height to the element (`clearfix` is the fix for this)

#### Absolute Positioning

- Element is removed from the normal flow
- No impact on surrounding content or elements
- We use `top`, `bottom`, `left`, `right`

### Stacking Context

Are like layers to "paint" the stack. Most often adjusted with z-index, but others affect it to.

## CSS Architecture, Components, and BEM

**Component Driven Design** - Divide page into modular parts that makes up the interface. Components should be resusable and independent.

Have a structure for naming the classes. **BEM** is a way of naming CSS classes.

### Block Element Modifier (BEM)

A **block** is a standalone component that is meaningful on its own.

An **element** is part of a block that has no meaning on its own.

A **modifier** is a defferent version of a block or an element

Uses very low specificity classes. Here are the examples:

```CSS
.block {}
.block__element {}
.block__element--modifier {}
```

### Architecture

**7-1 Pattern** 7 different folders for partial Sass files, and 1 main Sass file (or other CSS preprocessor) to import all other files into a compiled CSS stylesheet.

- `base/` - basic product definitions
- `components/` - 1 file for each componet
- `layout/` - overall layout
- `pages/` - styles for specific pages
- `themes/` - if you want to have different themes
- `abstracts/` - variables and mixins
- `vendors/` - all 3rd party css

## CSS Preprocessor

An extention of CSS that adds power to the language. You write in another language (Less, SASS, Stylus). It is then compiled into CSS.

### SASS

Features SASS adds to CSS:

- **Variables** - Used for values like colors, font-sizes, spacing, etc.
- **Nesting** - Visually nest selectors within each other. Easier to understand and less code needed
- **Operators** - Can do mathematical operations inside of CSS
- **Partials and Imports** - Can split CSS into different and more maintainable files
- **Mixins** - Reusable chunks of code
- **Functions** - Similar to mixins, but they produce a value that can be used
- **Extends** - To make different selectors inherit declarations that are common to all of them
- **Control Directives** - For writing complex code using conditionals and loops (not covered in Udemy course)

#### Different SASS Syntax

SASS has two different syntaxes. SASS is indent-based (like Python). SCSS is closer to CSS with {}. The advantage of SCSS is that any CSS file is already valid SCSS. So, it's easy to convert projects.

```Sass
.nav
  list-style: none
  float: left

  & li
    display: inline-block
    margin-left: 30px
```

```SCSS
.nav {
  list-style: none;
  float: left;

  & li {
    display: inline-block;
    margin-left: 30px;
  }
}
```

repository: TylerAuer/cheat-sheets-and-tutorials

repo_name: TylerAuer/cheat-sheets-and-tutorials


text:
# appleAppStoreAPI
Python script to pull detail of Apps on Apple's App Store via their API

This is a simple script that uses Apple's App Store API to pull search details of whichever music, movies or apps that you are looking for.

The output is dropped into a CSV file that can be imported into Excel. The parsing character is set to caret '^'.

A list of all the fields that are available for the API is here:

https://affiliate.itunes.apple.com/resources/documentation/itunes-store-web-service-search-api/

repository: LiamsGitHub/appleAppStoreAPI

repo_name: LiamsGitHub/appleAppStoreAPI