text:
# remote_fx collector

The remote_fx collector exposes Performance Counters regarding the RemoteFX protocol (RDP). It exposes both network and graphics related performance counters.

|||
-|-
Metric name prefix  | `remote_fx`
Data source         | Perflib
Classes             | [`Win32_PerfRawData_Counters_RemoteFXNetwork`](https://wutils.com/wmi/root/cimv2/win32_perfrawdata_counters_remotefxnetwork/), [`Win32_PerfRawData_Counters_RemoteFXGraphics`](https://wutils.com/wmi/root/cimv2/win32_perfrawdata_counters_remotefxgraphics), [more info...](https://docs.microsoft.com/en-us/azure/virtual-desktop/remotefx-graphics-performance-counters)
Enabled by default? | No

## Flags

None

## Metrics (Network)

Name | Description | Type | Labels
-----|-------------|------|-------
`windows_remote_fx_net_base_udp_rtt_seconds` | Base UDP round-trip time (RTT) detected in seconds. | gauge | `session_name`
`windows_remote_fx_net_base_tcp_rtt_seconds` | Base TCP round-trip time (RTT) detected in seconds. | gauge | `session_name`
`windows_remote_fx_net_current_tcp_bandwidth` | TCP Bandwidth detected in bytes per second. | gauge | `session_name`
`windows_remote_fx_net_current_tcp_rtt_seconds` | Average TCP round-trip time (RTT) detected in seconds. | gauge | `session_name`
`windows_remote_fx_net_current_udp_bandwidth` | UDP Bandwidth detected in bytes per second. | gauge | `session_name`
`windows_remote_fx_net_current_udp_rtt_seconds` | Average UDP round-trip time (RTT) detected in seconds. | gauge | `session_name`
`windows_remote_fx_net_received_bytes_total` | _Not yet documented_ | counter | `session_name`
`windows_remote_fx_net_sent_bytes_total` | _Not yet documented_ | counter | `session_name`
`windows_remote_fx_net_udp_packets_received_total` | Rate in packets per second at which packets are received over UDP. | counter | `session_name`
`windows_remote_fx_net_udp_packets_sent_total` | Rate in packets per second at which packets are sent over UDP. | counter | `session_name`

## Metrics (Graphics)

Name | Description | Type | Labels
-----|-------------|------|-------
`windows_remote_fx_gfx_average_encoding_time_seconds` | Average frame encoding time. | gauge | `session_name`
`windows_remote_fx_gfx_frame_quality` | Quality of the output frame expressed as a percentage of the quality of the source frame. | gauge | `session_name`
`windows_remote_fx_gfx_frames_skipped_insufficient_resource_total` | Number of frames skipped per second due to insufficient resources. resources are client, server or network. | counter | `session_name`, `resource`
`windows_remote_fx_gfx_graphics_compression_ratio` | Ratio of the number of bytes encoded to the number of bytes input. | gauge | `session_name`
`windows_remote_fx_gfx_input_frames_total` | Number of sources frames provided as input to RemoteFX graphics per second. | counter | `session_name`
`windows_remote_fx_gfx_output_frames_total` | Number of frames sent to the client per second. | counter | `session_name`
`windows_remote_fx_gfx_source_frames_total` | Number of frames composed by the source (DWM) per second. | counter | `session_name`

### Example metric
_This collector does not yet have explained examples, we would appreciate your help adding them!_

## Useful queries
_This collector does not yet have any useful queries added, we would appreciate your help adding them!_

## Alerting examples
_This collector does not yet have alerting examples, we would appreciate your help adding them!_


text:
[![Netlify Status](https://api.netlify.com/api/v1/badges/92f7b12e-9aa2-4f3a-9847-16907614b089/deploy-status)](https://app.netlify.com/sites/css-houdini-experiments/deploys)

# CSS Houdini Experiments

> If you want more information about **CSS Houdini**, please visit the [Awesome CSS Houdini](https://github.com/CSSHoudini/awesome-css-houdini) to access to a lot of documentation, samples, videos and articles.

To view samples run `npm install` or `yarn install` to install dependencies, only to have a web server to navegate the samples folders.

Then run `npm start` to run web server and enjoy it.

## Paint API

- [Circles](app/experiments/paint/circles/)
- [Circles with properties](app/experiments/paint/circles-props/)
- [Circles with arguments](app/experiments/paint/circles-args/)
- [Circles with properties and change values with Javascript](app/experiments/paint/circles-props-js/)
- [Circles with properties and change values with Mouse Event](app/experiments/paint/circles-props-js-mouse/)
- [Circles with properties into Web Component](app/experiments/paint/circles-props-web-component/)

## Properties & Values API

- TODO

## Typed OM API

- TODO

## Animation Worklet

- [Logo Animation](app/experiments/animation-worklet/logo-animation/)
- [Logo Scroll Animation](app/experiments/animation-worklet/logo-scroll-animation/)

## Layout Worklet

- TODO

> If you have got any suggestion or use case, please open an [issue](https://github.com/nucliweb/houdini/issues/new)

---

## More samples

You have got a lot of samples and documentation on [Awesome CSS Houdini](https://github.com/CSSHoudini/awesome-css-houdini)

license: MIT

repository: nucliweb/houdini

branch_name: refs/heads/master

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive

repo_name: nucliweb/houdini


text:
###### LESSON 1

### Terminology, Syntax, & Introduction

Before beginning our journey to learn HTML and CSS it is important to understand the differences between the two languages, their syntax, and some common terminology.

As an overview, **HTML** is a hyper text markup language created to give content structure and meaning. **CSS**, also known as `cascading style sheets`, is a presentation language created to give content style and appearance.

To put this into laymen terms, HTML determines the structure and meaning of content on a web page while CSS determines the style and appearance of this content. The two languages are independent of one another. CSS should not reside within an HTML document and vice versa.

Taking this concept a bit further, the HTML `p` element is used to display a paragraph of text on a web page. The `p` element is specifically used here as it is provides the most value for the content, thus being the most semantic element. CSS then uses a type selector of p which can determine the color, font size, font weight, and other stylistic properties of the paragraph. More on this to come.

### Common HTML Terms

When getting started with HTML you are likely to hear new, and often strange, terms. Over time you will become more and more familiar with all of them but three terms you should learn today include tags, elements, and attributes.

#### Elements

Elements are designators that define objects within a page, including structure and content. Some of the more popular elements include `h1` through `h6`, `p`, `a`, `div`, `span`, `strong`, and `em`.

```html
<a>
```

#### Tags

Elements are often made of multiple sets of tags, identified as opening and closing tags. **Opening tags** mark the beginning of an element, such as `<div>`. **Closing tags** mark the end of an element and begin with a forward slash, such as `</div>`.

```html
<a>...</a>
```

#### Attributes

Attributes are properties used to provide additional instruction to given elements. More commonly, attributes are used to assign an `id`, `class`, or `title` to an element, to give media elements a source (`src`), or to provide a hyperlink reference (`href`).

```html
<a href="http://www.shayhowe.com/">Shay Howe</a>
```

Common HTML Terms Example

[Shay Howe](http://www.shayhowe.com/)

### HTML Document Structure & Syntax

All HTML documents have a required structure that includes the following declaration and tags: `doctype`, `html`, `head`, and `body`.

The `doctype` declaration is used to instruct web browsers which version of HTML is being used and is placed at the very beginning of the HTML document. Following the `doctype` declaration, `html` tags signify the beginning and end of the document.

The `head of` the document is used to outline any `meta` data, the document `title`, and links to any external files. Any context included within the `head` tags is not visible within the actual web page itself. All of the content visible within the web page will fall within the `body` tags.

A general HTML document structure looks like the following:

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Hello World</title>
  </head>
  <body>
    <h1>Hello World</h1>
    <p>This is a website.</p>
  </body>
</html>
```

### Common CSS Terms

In addition to HTML terms, there are some common **CSS terms** you will want to familiarize yourself with. The more you work with HTML and CSS the more these terms will become second nature.

#### Selectors

A selector determines exactly which element, or elements, the corresponding styles will be applied. Selectors can include a combination of different IDs, classes, types, and other attributes – all depending on how specific you wish to be. Selectors can be identified as everything that comes before the first curly brace, `{`.

```css
p { ... }
```

#### Properties

A property determines the style that will be applied to an element. Properties can be identified as the text coming immediately before a colon. There are an abundance number of properties you can use, and new ones are continually being added.

```css
p {
  color: #ff0;
  font-size: 16px;
}
```

#### Values

A value determines the behavior of a property. Values can be identified as the text in-between the colon and semicolon.

```css
p {
  color: #ff0;
  font-size: 16px;
}
```

### CSS Structure & Syntax

CSS works by using selectors to apply styles to HTML elements. All CSS styles cascade, allowing different styles to be inherited by multiple elements.

As an example, it is possible to set one style for all of the text on a page to be of a specific color, size, and weight. Then by using a more targeted selector that style can be overwritten for a unique element.

```code
Selector -> p {
  Declaration-> color: #ff0;
                font-size: 16px;
              }    |        |
                Property    Value
```

The following syntax demonstrates how styles would be applied to every paragraph.

```css
p {
  color: #ff0;
  font-size: 16px;
}
```

#### Long vs. Short Hand

In CSS there are multiple different ways to declare values for a property. With long hand CSS you stack multiple declarations, one after the other for each property and value. With short hand CSS you use one property and list multiple values. It is best to use short hand CSS as it requires less code. Not all properties support short hand CSS so make sure you are using the correct property and value structure.

```css
/* Long Hand */
p {
  padding-top: 10px;
  padding-right: 20px;
  padding-bottom: 10px;
  padding-left: 20px;
}
/* Short Hand */
p {
  padding: 10px 20px;
}
/* Short Hand */
p {
  padding: 10px;
}
```

#### Comments within HTML & CSS

HTML and CSS give you the ability to leave comments within the code. These comments can be used to help with organization, set reminders, and manage code more effectively. Comments become especially useful when there are multiple people working on the same code. Any content wrapped within comments will not be rendered on the page.

HTML comments wrap the content starting with . CSS comments wrap the content starting with /* and end with */.

### Selectors

Selectors, as mentioned earlier, are the determining factor as to which elements are to be stylized. In so, it is important to fully understand how to use selectors and how they can be leveraged. Some of the most common selectors include elements, IDs, and classes, or some combination of the three.

#### Type Selectors

Type selectors are the most basic selector. Simply enough, elements without any necessary attributes are targeted to apply styles. Type selectors are preferred whenever possible as they require less code and are easy to manage.

```html
<p>...</p>
```

```css
p { ... }
```

#### Class Selectors

Class selectors allow you to apply the same style to an array of elements by giving them all the same class attribute. Classes are denoted in CSS by identifying the class with a leading period. It is permissible to use the same class attribute on multiple elements on a page.

```html
<div class="awesome">...</div>
```

```css
.awesome { ... }
```

#### ID Selectors

ID selectors are similar to class selectors however they are used to target only one unique element at a time. Instead of using the class attribute, IDs naturally use the ID attribute. In place of a period, as with classes, IDs are denoted by identifying the ID with a leading hash sign. IDs are only allowed to be used once per page and should ideally be reserved for significant elements.

```html
<div id="shayhowe">...</div>
```

```css
#shayhowe { ... }
```

#### Combining Selectors

A beauty of CSS is the ability to combine selectors and inherit styles. This allows you to start with a more generic selector and work your way to being more specific as necessary. In addition, you can combine different selectors to be as specific as you wish.

```css
ul#social li {
  padding: 0 3px;
}
ul#social li a {
  height: 17px;
  width: 16px;
}
ul#social li.tumblr a {
  background: url('tumblr.png') 0 0 no-repeat;
}
```

#### Additional Selectors

Selectors can be extremely powerful and the selectors outlined above are only the beginning. Many more [advanced selectors](http://coding.smashingmagazine.com/2009/08/17/taming-advanced-css-selectors/) exist and are readily available. Before dropping classes or IDs on random elements check and see if there might be a better selector to do the job for you. It is also worth mentioning that not all advance selectors work in every browser, particularly with new selectors introduced in CSS3. If a selector doesn’t seem to be working properly check its browser support.

### Referencing CSS

Once content is in place you may begin to style the HTML with CSS. There are a handful of different ways to reference CSS, some of which are better than others.

The best practice for referencing CSS is to include all of your styles within a single external stylesheet, referenced within the heading of a page. Using an external stylesheet allows you to use the same styles across an entire website and quickly make changes site wide.

Other options include internal and inline styles. These options are generally frowned upon as they make updating websites cumbersome and unwieldy.

```html
<!-- External CSS File -->
<link rel="stylesheet" href="file.css">
<!-- Internal CSS -->
<style type="text/css">
p {
  color: #f60;
  font-size: 16px;
}
</style>
<!-- Inline CSS -->
<p style="color: #f60; font-size: 16px;">Lorem ipsum dolor sit amet...</p>
```

#### Using External CSS Stylesheets

As mentioned above, the best way to reference CSS is with an extrenal stylesheet. Doing so allows you to use one set of styles across an entire website. Making changes to the style of a website becomes painless, and users download less data overall to properly render the styles.

Within the `head` of the HTML document, the `link` element is used to define the relationship between the HTML file and the CSS file. Since you are linking to CSS the `rel` attribute with a value of `stylesheet` is used to specify the relationship. Furthermore, the `href` attribute is used to identify the location, or path, of the CSS file.

In order for the CSS to render, the path of the `href` attribute value must directly correlate to where the CSS file is stored. In the example above the `file.css` is stored within the root directory, the same location as the HTML file.

Should the CSS be within a subdirectory, the `href` attribute value would need to correlate this path accordingly. For example, if the `file.css` is stored within a subdirectory call `styles` the `href` attribute value would be `styles/file.css`, using a forward shash to indicate different directories.

### Reset

By default every web browser has it’s own interpretation on how different elements are to be stylized. How Chrome decides to render an input field is likely going to be much different than how Internet Explorer renders an input field. To combat for **cross browser compatibility** CSS resets have become widely used.

  **Cross Browser Compatibility & Testing**

  As mentioned, different browsers render pages in different ways. Its important to recognize the value in cross browser compatibility and testing. Websites don’t need to look the same in every browser but they should be close. What browsers you wish to support and to what degree is a decisions you will need to make in accordance with what is best for your website.

CSS resets include a handful of rule sets that take every common HTML element and scale them down to one unified style. These resets involve removing any sizing, margins, paddings, or additional styles. Resets need to be the very first CSS styles to be rendered to ensure that all the styles there after are being applied to the skeleton of a page.

There are a ton of different resets available to use, all of which have their own forte. My personal favorite is [Eric Meyers reset](http://meyerweb.com/eric/tools/css/reset/), which has been adapted to include a reset for the new HTML5 elements. Eric’s reset is short and to the point, but feel free to research your own resets and find what you’re comfortable using.

  ## Code Validation

  As proficient as we all are, we do make mistakes. Thankfully when writing HTML and CSS we have a validator that can check our work. The W3C has built both [HTML](http://validator.w3.org/) and [CSS](http://jigsaw.w3.org/css-validator/) validators that will scan your code looking for mistakes. Validating your code not only helps it render properly across all browsers, it also teaches you the best practices for writing code.

### Resources & Links

* [Common HTML Terms](http://www.scriptingmaster.com/html/HTML-terms-glossary.asp) via Scripting Master
* [CSS Glossary](http://www.codestyle.org/css/Glossary.shtml) via Code Style
* [Taming Advanced CSS Selectors](http://coding.smashingmagazine.com/2009/08/17/taming-advanced-css-selectors/) via Smashing Magazine
* [CSS Tools: Reset CSS](http://meyerweb.com/eric/tools/css/reset/) via Eric Meyer
* [An Intro to HTML & CSS](http://www.shayhowe.com/web-design/intro-to-html-css/) via Shay Howe

extension: markdown


text:
# tdx

The Data Xplorer

![build status](https://github.com/sundayoyeniyi/tdx/workflows/TDX%20Deployment%20Workflow/badge.svg)

## Introduction

## Technology mention

1. [Gradle](https://gradle.org/guides/#getting-started) for project build automation
1. [GitHub Actions](https://github.com/features/actions) platform choice for running build, test and deployment

## Contributing

repository: sundayoyeniyi/tdx

gha_language: JavaScript

repo_name: sundayoyeniyi/tdx


text:
+ npm init
+ build and watch scripts - *watchify*
+ *-v* & *-d*
```json
  {
    "scripts": {
      "build": "browserify src/index.js -o dist/bundle.js -d",
      "watch": "watchify src/index.js -o dist/bundle.js -v -d"
    }
  }
```

Note:
+ -v is for verbose
+ -d is for debug
    * maps the src files, so you can go to the individual source files in chrome dev tools
+ point out how the first argument is the source and the second argument is the destination
+ another option is a gulp task.
    * that's an advanced topic, this keeps it simple.

repository: daveharmswebdev/barcamp-presentation

repo_name: daveharmswebdev/barcamp-presentation


text:
# CryptoAuthLib

This is a port of the Atmel
[CryptoAuthLib](http://www.atmel.com/tools/CryptoAuthLib.aspx) library
for the Arduino platform.

This is **beta** release, see disclaimer below.

## Installation

1. Download the CryptoAuthLib-v*xyz*.zip from the [latest release](https://github.com/sathibault/cryptoauthlib/releases)
2. From Arduino IDE menu select Sketch -> Include library -> Add .ZIP library and select the downloaded file.

## Examples

See provision_sha204 for an example of provisioning a device and using
it to computing challenge responses with symmetric keys with the
ATSHA204A chip.

See provision_ecc108 for an example of provisioning a device and using
it to generate private/public key pairs, signing messages, and
validating signed messages with the ATECC108A chip.

## License

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

3. The name of Atmel may not be used to endorse or promote products derived
   from this software without specific prior written permission.

4. This software may only be redistributed and used in connection with an
   Atmel integrated circuit.


text:
---
productId: joy-ui
title: React Toggle Button Group component
githubLabel: 'component: toggle button'
components: ToggleButtonGroup, Button, IconButton
---

# Toggle Button Group

A group of mutually exclusive buttons.

## Introduction

Toggle Button Group provides a way to get mutually exclusive actions closer together by sharing a common container.
It controls the selected state of its child buttons when given its own `value` prop.

{{"demo": "ToggleGroupUsage.js", "hideToolbar": true, "bg": "gradient"}}

## Basics

```jsx
import ToggleButtonGroup from '@mui/joy/ToggleButtonGroup';
```

Note that Joy UI doesn't provide a Toggle Button component but rather a Toggle Button Group container component. The reason for that is that according to the [WAI ARIA pattern](https://www.w3.org/WAI/ARIA/apg/patterns/button/), it's better to use `aria-pressed` on the Button or Icon Button component instead.

{{"demo": "ToggleButtons.js"}}

That said, when using the Toggle Button Group component, pass a value as an array.
When a button within the group is pressed, the Toggle Button Group component triggers the `onChange` prop of it and passes the updated array as a parameter.

The Toggle Button Group component uses the same styles as the [Button Group](/joy-ui/react-button-group/) component to ensure a consistent visual connection between all of the Joy UI buttons.

{{"demo": "ToggleGroup.js"}}

### Exclusive selection

When the value provided to the Toggle Button Group component is not an array, it operates in the exclusive selection mode, which means that only one button can be selected at a single time within the group.

{{"demo": "ExclusiveSelection.js"}}

## Customization

### Variants

The Toggle Button Group component supports Joy UI's four [global variants](/joy-ui/main-features/global-variants/): `outlined` (default), `plain`, `soft`, and `solid`.

{{"demo": "ToggleGroupVariants.js"}}

:::info
To learn how to add your own variants, check out [Themed components—Extend variants](/joy-ui/customization/themed-components/#extend-variants).
Note that you lose the global variants when you add custom variants.
:::

### Sizes

The Toggle Button Group component comes in three sizes: `sm`, `md` (default), and `lg`.

{{"demo": "ToggleGroupSizes.js"}}

:::info
To learn how to add custom sizes to the component, check out [Themed components—Extend sizes](/joy-ui/customization/themed-components/#extend-sizes).
:::

### Colors

Every palette included in the theme is available via the color prop.

{{"demo": "ToggleGroupColors.js"}}

### Spacing

By default, there's no spacing between the buttons within a Toggle Button Group.
Use the `spacing` prop with a value greater than 0 to separate each button.

The spacing is applied using the `gap` CSS property and its value is determined on the theme `theme.spacing(<value>)`).

{{"demo": "ToggleGroupSpacing.js"}}

To create a responsive spacing scale, the `<value>` can be an object or an array.

```js
<ToggleButtonGroup spacing={{ xs: 0, md: 2, lg: 3 }}>…</ToggleButtonGroup>
```

## Common examples

### Figma-like toggle group

Use the CSS variable `--ButtonGroup-connected` to control when border radius of the buttons in-between should be removed.

To create a Figma-like button group where the buttons are connected when users hover on any of the buttons, set the `--ButtonGroup-connected` to `0` and change to `1` on hover.

{{"demo": "FigmaButtonGroup.js"}}

### Editor toolbar

{{"demo": "ToggleGroupToolbar.js"}}

## Accessibility

### ARIA

- The Toggle Button Group component has `role="group"`. Make sure to provide an accessible label with `aria-label="label"`, `aria-labelledby="id"` or `<label>`.
- For the toggle button, set `aria-pressed="<bool>"` according to the button state. Make sure to label an icon button with `aria-label`.

### Keyboard

Buttons within a Toggle Button Group component are in the same order as in the DOM.
Use the tab key to navigate them.


text:
## PROJECT NAME
 - THE PIZZA-BOX
 ## Author's Name
 - SHALOM PAULINE ODIDA

## Setup instructions
 - git clone or download the zip file.

 - Extract the zip file.

 - cd project folder.

 - launch the index.html file.

## Technology Used
 - HTML-I used html for displaying the content.
 - CSS-I used css and bootstrap for styling the front-end of the website and making the landing page.
 - JAVASCRIPT-I used javascript for dynamics.

## BDD.

  - At the home page, you will  press the order button and it will enable you select your favorite options of pizza.

   - Here you will be able to  select the size, toppings and the crust then checkout with the checkout button to get the total prize to be paid. You'll then procced to click ok button
   untill you get the last alert welcoming you back.

## Project's live Link
 - Github link:
## Contact information.
 - Email<EMAIL_ADDRESS>
## License and Copyright information.
 - MIT License Copyright (c) 2020 (shalom pauline odida)
 -  [MIT License][Shalom](https://github.com/Shalom)

repository: shalomodida/The-Pizza-Box

repo_name: shalomodida/The-Pizza-Box


text:
# FLAME
### Friends, Lovers, Affectionate, Marriage, Enemies

[![Build Status](https://img.shields.io/travis/jozsefsallai/flame.svg?style=flat-square)](https://travis-ci.org/jozsefsallai/flame)
[![Dependencies](https://img.shields.io/david/jozsefsallai/flame.svg?style=flat-square)](https://david-dm.org/jozsefsallai/flame)
[![Coverage](https://img.shields.io/coveralls/github/jozsefsallai/flame/master.svg?style=flat-square)](https://coveralls.io/github/jozsefsallai/flame?branch=master)

Flame game for the command line and Node. Requires Node (8.x or later). [(How To Play)](https://www.wikihow.com/Play-%22Flame%22#Playing_FLAME_sub).

## Usage

### As Module

1. Install the package using npm or Yarn

```sh
npm i flame-game
# or
yarn add flame-game
```

2. Import the module

```js
const flame = require('flame-game');
```

3. Pass input to it

```js
// Two strings
flame('Joe', 'Missy');

// or an object
flame({
  firstName: 'Joe',
  secondName: 'Missy'
});
```

**Returned data:**

```js
{
  relationship: 'affectionate', // result of the algorithm
  firstName: 'Joe',             // the original name 1
  secondName: 'Missy'           // the original name 2
}
```

### In the CLI

1. Install the program globally

```sh
npm i -g flame-game
```

2. Run `flame` and enter some input.

## Contribution

Linting:

```
yarn lint
```

Unit tests:
```
yarn test
```

## License

MIT

repository: jozsefsallai/flame

repo_name: jozsefsallai/flame


text:
# Last-Word

description: Record the last word to let everyone leave something.

## User Stories

The following **required** functionality is completed:

* T [*] User can sign in with ***Facebook*** or Google+
   * T [*] Request Permission of Friend List, Public Profile, Email
* A [*] Implement different scenes with dynamic background
* A [*] User can use the front camera try to record the video
* T [*] App has a centralize backend service to keep user's profile and videos
   * T [*] User Email, Viedo URL , Password, Local or remote, Category
   * T [*] API for insert video url, get list of video url by user mail.
   * T [*] Video Object include url, category, user email, password, length, format (codec)
* A [*] App can upload the user videos to Dailymotion as long as internet availible
* A [*] User can choose different perspective to show their appreciations
* T [*] User can view the videos they have recorded.
   * T [*] 1. User can see the first frame of their video in the video list.
* [*] User can share the video to others by system default share action.
* [*] User can copy the link in the video playing page.

The following **bonus** features are implemented:
* [*] Polish the user login screen and customize facebook login button
* [*] Polish the feeling of first open activity
* [*] Available on Google Play Store
* [] User can play their video on Dailymotion if there is no file on device
* [] User can set the password to protect their videos.
* [] Change the VideoView to ExoPlayer
* [] User can view the videos length
* [] App only upload videos on the wifi environment

## Video Walkthrough

Here's a walkthrough of implemented user stories:

[Imgur video walkthrough](http://i.imgur.com/fLbbqlK.gifv)

https://github.com/AppleOctopus/Last-Word/blob/master/LW_1_.mp4

GIF created with [Jeff]

## Notes

Describe any challenges encountered while building the app.

## Open-source libraries used

- [OkHTTP]
- [Retrofit]
- [gson]
- [Picasso]

## License

    Copyright AppleOctopus

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: AppleOctopus/Last-Word

repo_name: AppleOctopus/Last-Word


text:
# Psr2 Code Generator Contributing Guide

## Workflow

1. Fork, clone and apply your patches.
2. Run the test suite `composer test` and fix all red tests.
3. Run static analysis tool (by now, we use [Psalm](https://psalm.dev/)) `composer analytics` and fix all errors and issues.
4. Fix the coding standard `composer cs-fix`.

!!! note "Tip"
    We provide a __check__ command to run all the tests and analytics, required for a pull request.
    Run `composer check`

## Running the Test Suite

While developing, the test part is very important: if you apply a patch to the existing code, the test suite must run without
errors or failures and if you add a new functionality, no one will consider it without tests.

Our test tool is [PhpUnit](https://phpunit.de/) and we provide a script to launch it:

```bash
composer test
```
Since our command runs phpunit binary under the hood, you can pass all phpunit options to it via the `--` operator, i.e.:
```bash
composer test -- --stop-on-failure
```
You can also use phpunit directly:
```
vendor/bin/phpunit
```

## Code Coverage

We provides two commands to generate a code coverage report in _html_ or _xml_ format.

`composer coverage:html` command generates a code coverage report in _html_ format, into the directory `coverage/` while
`composer coverage:clover` generates the report in _xml_ format, into `clover.xml` file.

## Static Analysis Tool

To prevent as many bugs as possible, we use a static analysis tool called [Psalm](https://psalm.dev/).
To launch it, run the following command from the root directory of psr2-code-generator project:

```bash
composer analytics
```

After its analysis, Psalm outputs errors and issues with its suggestions on how to fix them. Errors are more important
and generally more dangerous than issues, anyway you should fix both.

## Coding Standard

We ship our script to easily fix coding standard errors, via [php-cs-fixer](https://cs.symfony.com/) tool.
To fix coding standard errors just run:

```bash
composer cs-fix
```
and to show the errors without fixing them, run:
```bash
composer cs
```
If you want to learn more about our code style, see [https://github.com/susina/coding-standard](https://github.com/susina/coding-standard).

## Documentation Contributing

psr2-code-generator documentation resides into the directory `docs/`. It's written in [markdown](https://daringfireball.net/projects/markdown/)
and it's generated by [MkDocs](https://www.mkdocs.org).

### Install the Tools

If you want to contribute to the documentation, you should install the following tools, to generate it locally:

1. [Install MkDocs](https://www.mkdocs.org/#installation)
2. Install [Material theme](https://squidfunk.github.io/mkdocs-material/) by running: `pip install mkdocs-material`

### Markdown flavour

MkDocs uses [Python-Markdown](https://python-markdown.github.io/) with some extensions active by default. It supports the
standard markdown, markdown-extra and some of the Github-flavoured markdown features. You can find detailed information on
[https://www.mkdocs.org/user-guide/writing-your-docs/#writing-with-markdown](https://www.mkdocs.org/user-guide/writing-your-docs/#writing-with-markdown).

### Admonition

[admonition](https://python-markdown.github.io/extensions/admonition/) extension helps to write beautiful notes or
warnings or other (see the official documentation) with a syntax like the following:

```bash
!!! Danger
    Very dangerous operation!
```

which translates into the following:

!!! Danger
    Very dangerous operation!


text:
Wondering what the Windows 8 Metro UI will look and feel like? See the great work of [Stephen Horlander][1] and [Yuan Wang][2] here:

[Video Sketching Firefox Metro Start Page][3]

[1]: http://stephenhorlander.com/
[2]: http://yuanwong.com/
[3]: http://blog.mozilla.org/ux/2012/05/video-sketching-firefox-metro-start-page/


text:
# An Emacs Lisp Complex Number Library

The "cplx" package represents complex numbers as a pair of floats in a
cons cell.

Except for the constructors, `cplx` and `cplx-const`, and type
predicate, `cplx-p`, each function accepts only complex numbers,
returning either a complex number or scalar as appropriate. To pass a
scalar, represent it as a complex number with a zero imaginary
component, e.g. `(cplx 1.0 0.0)`.

To efficiently embed complex constants in within a compiled function's
constants vector, use the `cplx-const` macro. The alternative would be
to construct them repeatedly at run time on demand, or continually
fish them from a global variable.

```el
(let ((i (cplx-const 0.0 1.0)))
   ...)
```

Constructor, predicate, and accessors:

* `(cplx real imag)`
* `(cplx-const real imag)`
* `(cplx-p object)`
* `(cplx-real c)`
* `(cplx-imag c)`

Operators:

* `(cplx-+ a b)`
* `(cplx-- a b)`
* `(cplx-* a b)`
* `(cplx-/ a b)`

Functions:

* `(cplx-abs c)`
* `(cplx-arg c)`
* `(cplx-conj c)`
* `(cplx-proj c)`
* `(cplx-sqrt c)`
* `(cplx-sin c)`
* `(cplx-cos c)`
* `(cplx-tan c)`
* `(cplx-log c)`
* `(cplx-asin c)`
* `(cplx-acos c)`
* `(cplx-atan c)`
* `(cplx-zerop c)`
* `(cplx-exp c)`
* `(cplx-expt a b)`

## Philosophy

This package is optimized for a byte code compiler that does not yet
exist. Every function in this package is defined as inlined (e.g.
`defsubst`), and there are no versions of any of these functions that
accept plain scalars. With the current Emacs byte code compiler,
functions that call many complex number functions will compile to much
larger byte code objects than necessary and will perform a little
slower than strictly necessary.

In practice, complex number functions are not called in isolation.
Many complex operations are typically performed at once on multiple
values. By inlining every complex number function call, the byte code
compiler can *theoretically* optimize across all these calls. Using
escape analysis — especially with lexical scope — the compiler could
elide most intermediate complex number objects, eliminating
unnecessary consing. Constants could be folded, particularly in the
case of `cplx-const`. Dead code could be removed.

None of this requires a "[sufficiently smart compiler][opt]". These
are straightforward, routine compiler optimizations. Unfortunately the
current Emacs byte code compiler just doesn't do any of these things.
This package is optimistic, assuming that one day it will.

Also unfortunately, multiply-by-zero cannot generally be optimized for
floating point values due to the presence of NaN, infinity, and
negative zero. This prevents some scalar constant operations from
being optimized. For example, while this would be great, this would
*not* be a valid optimization by the byte compiler:

```el
;; before;
(cplx-* (cplx-const 2.0 0.0) c)

;; after:
(cons (* 2.0 (car c)) (* 2.0 (cdr c)))
```

A nice side effect of all the function inlining is that this package
is like a macro-only package, only required at compile time. The
`require` for this package can be wrapped in an `eval-when-compile`.

[opt]: http://wiki.c2.com/?SufficientlySmartCompiler

license: Unlicense

repository: skeeto/cplx

repo_name: skeeto/cplx


text:
barrel_erocksdb
===============

**This is a fork of https://github.com/barrel-db/barrel_rocksdb with DbWithTTL instead of simple Db and with static
linking, including static `libstdc++` but not including `libc`. Some tests are failing, don't use anything like
`updates_iterator`, `binary_update` and transactions. The rest things seem working.**

**Contains patch for rocksdb db_ttl_impl.**

**Don't forget to change path to `libstdc++.a` in rebar.config. Also you may or may not have to compile your
own custom build of gcc
with `./configure CXXFLAGS=-fPIC CFLAGS=-fPIC --enable-languages=c,c++ --disable-gnu-unique-object`**

Erlang bindings to [RocksDB](https://github.com/facebook/rocksdb) datastore.

This binding is a fork of [erocksdb](https://github.com/leo-project/erocksdb)
customized for the [Barrel DB](https://barrel-db.org) project.

Main differences are the following:

- Erlang 19 and sup only
- Use dirty-nifs
- Complete refactoring of the source code under the `erocksdb` namespace
- add single put and single delete operations
- add functions to handle the transactions logs

## Build Information

    $ rebar3 eunit

## License

barrel_rocksdb's license is [Apache License Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html)


text:
---
_id: 5e3a535636deea0036c54b29
title: "Tips & tricks for unit testing in .NET Core 3: Checking matching and non matching arguments on ILogger"
url: 'http://anthonygiretti.com/2020/02/05/tips-tricks-for-unit-testing-in-net-core-3-checking-matching-and-non-matching-arguments-on-ilogger/'
category: articles
slug: 'tips-and-tricks-for-unit-testing-in-net-core-3-checking-matching-and-non-matching-arguments-on-ilog'
user_id: 5e33901136deea0036c54b06
username: 'anthonygiretti'
createdOn: '2020-02-05T05:32:06.172Z'
tags: [.net-core]
---

You must have been like me for a long time unable to do one thing with ILogger: test the arguments that are passed to its methods during your unit tests. You must most likely use extension methods such as LogDebug, logError etc …… and indeed you can neither mock nor test the arguments passed to them. We will see in this article how to get around this difficulty in order to finally be able to test arguments passed to extension methods of ILogger.

repository: dotnetweekly/dnw-gatsby

repo_name: dotnetweekly/dnw-gatsby


text:
# recalbox-patcher

## Overview
recalbox-patcher is a software to patch Recalbox game file with information from Hyperspin file.

The software is developed with the following technologies:
* Java 8
* Java FX
* Gradle 3.4+

## Modules

* **patcher**: the main library for patching game fies
* **rich-client**: a rich client application

## Sources
* [Recalbox web site](https://www.recalbox.com/)
* [Hyperspin web site](http://www.hyperspin-fe.com/)

repository: gofannon-io/recalbox-patcher

repo_name: gofannon-io/recalbox-patcher


text:
# Ski Resort Finder

#### _Ski Resort Locator, 04/09/2018_

### By _**Randy Weyer, Brian Henry, Justin Roller, David Tumpowsky**_

## Description
This website allows users to locate the closest ski resort from their current location or any location they want to start from.

### Specs
| Spec | Input | Output |
| :-------------     | :------------- | :------------- |
| **Homepage** | User accesses one of our Repository's | ski-resort-finder.html|
| **Main Menu** | Map start location is Salt Lake City | Ski Resorts of Salt Lake City are shown and can be explored. |
| **Program gathers user input**| User Input: Clicks "Share Location" button to get the exact coordinates of where you are.  | Output: Shows ski resorts within 50 mile radius of your location to start. |
| **Program map can be dragged and changed to look in anywhere for a Ski Resort in US**| Input: "Drags pin to North Dakota" | Output: "Huff Hills shows up with all info" |
| **User clicks on Directions and website** | Input: "Clicks Directions" "Clicks resorts website" | Output: "Directs you to google maps and shows you exact directions from where your pin is located" "Directs you to resorts website so you can explore and book a vacation" |

## SetUp/Installation
* _Clone repository from GitHub._
* _Click to open HTML file on browser_
* _Get your current location with share location_
* _Explore and enjoy, and find your nearest Resort or any Resort in the Continental US._

## Technology Used
* HTML
* CSS
* JavaScript
* Bootstrap
* jQuery

## Known Bugs
* _No Known Bugs_

## Support and contact details

*<EMAIL_ADDRESS>- Justin Roller_
*<EMAIL_ADDRESS>- Randy Weyer_
*<EMAIL_ADDRESS>- Brian Henry_
*<EMAIL_ADDRESS>- David Tumpowsky_

### License
Copyright (c) 2018 Randy Weyer, Brian Henry, Justin Roller, David Tumpowsky.
This software is licensed under the MIT license.

repository: dtumpowsky/ski-resort-finder

repo_name: dtumpowsky/ski-resort-finder


text:
## Using C++

This example is for someone who is either given C++ code or knows C++ and wants to integrate it with python.

We write the function in C++ and then returning the answer to python allowing us to plot it or use it as a calculation for anther python function.

## Building and using cython modules

In each folder there are setup.py and CMake build scripts to build the example.

I recommend using cmake to build with C++ because a lot of 3rd party C++ libraries support cmake allowing you to more easily incorporate 3rd party tools.

To build using setup.py:
```bash
python setup.py build_ext --inplace
```

To build using CMake:
```bash
mkdir build
cd build
cmake ..
make
```

To use module the shared library which is built (`wave_propogation.cpython-{PYVER}-{PLATROM}.so`) it should either be in your current directory, or in a directory accessible by your `$PYTHON_PATH`. It can also be in a sub folder such as build by using `.`'s in place of `/`.

```python
import build.wave_propogation as wave_propogation
```


text:
# ![LOGO](logo.png) OSDB REST API v1 **flow**ground Connector

## Description

A generated **flow**ground connector for the OSDB REST API v1 API (version 1.0.0).

Generated from: https://api.apis.guru/v2/specs/openlinksw.com/osdb/1.0.0/openapi.json

Generated at: 2019-05-07T17:43:26+03:00

## API Description

An OpenAPI description of the OpenLink Smart Data Bot REST API v1

## Authorization

This API does not require authorization.

## Actions

### List actions

> Returns an array of action descriptions for the actions supported by the given service

*Tags:* `OSDB`

#### Input Parameters
* `serviceId` - _required_ - Service ID of the service for which actions are to be listed

### Describe action

> Returns a description of a given service action.

*Tags:* `OSDB`

#### Input Parameters
* `serviceId` - _required_ - Service ID of the service supporting the action.
* `actionId` - _required_ - Action ID of the action to describe.

### Execute action

> Executes a registered service action and returns any output from the action.

> The data returned in the POST response body may be:

> * the raw action output,

> * a URL encapsulating the action request which executes the action when dereferenced  (only for actions using GET),

> * RDF generated from the action output,

> * a URL to an RDF viewer's display of the generated RDF.

>

> Any parameters required by the action are supplied as a JSON object in the POST body. The parameter types supported are: "query", "header", "uri", "path" and "body".  The parameter type determines where a supplied parameter value is inserted into the HTTP request constructed by OSDB to invoke the target service action. In addition to native parameters required by the service action, 'Execute action' accepts some OSDB-specific parameters.

>

> **Examples**

> * ```curl -ik -X POST -d '{ "latitude":"37.7759792", "longitude":"-122.41823" }' -H 'Content-Type: application/json' https://osdb.openlinksw.com/osdb/api/v1/actions/uber/products/exec```

> * ```curl -ikL -X POST -d '{ "latitude":"37.7759792", "longitude":"-122.41823", "osdb:output_type":"generate_rdf", "osdb:response_format":"application/rdf+xml" }' -H 'Content-Type: application/json' https://osdb.openlinksw.com/osdb/api/v1/actions/uber/products/exec```

> * ```curl -ikL -X POST -d '{ "latitude":"37.7759792", "longitude":"-122.41823", "osdb:output_type":"display_rdf" }' -H 'Content-Type: application/json' https://osdb.openlinksw.com/osdb/api/v1/actions/uber/products/exec```

> * ```curl -ik -X POST -d '{ "q":"skiing", "osdb:response_format": "application/rdf+xml" }' -H 'Content-Type: application/json' https://osdb.openlinksw.com/osdb/api/v1/actions/facet/search/exec```

> * ```curl -ik -X POST -d '{ "q":"skiing", "osdb:output_type": "url_only" }' -H 'Content-Type: application/json' https://osdb.openlinksw.com/osdb/api/v1/actions/facet/search/exec```

> * ```curl -ik -X POST -d '{ "Content-Location": "http://demo.openlinksw.co.uk/pubs", "osdb:body_data_src_url": "http://ods-qa.openlinksw.com/DAV/home/osdb/pubs.csv", "extractor": "csv", "osdb:response_format": "application/rdf+xml", "osdb:body_data_encoding": "text/csv" }' -H 'Content-Type: application/json' https://osdb.openlinksw.com/osdb/api/v1/actions/csv_transformer/transform/exec```

*Tags:* `OSDB`

#### Input Parameters
* `serviceId` - _required_ - Service ID of the service supporting the action.
* `actionId` - _required_ - Action ID of the action to execute.

### Action help

> Returns the help text for a given service action

*Tags:* `OSDB`

#### Input Parameters
* `serviceId` - _required_ - Service ID of the service supporting the action.
* `actionId` - _required_ - Action ID of the action for which help text is being requested.

### Login

> Logs a user into the OSDB server, authenticating them by their WebID and returning an OSDB session ID in cookie osdb.sid

*Tags:* `OSDB`

### Logout

> Logs a user out of the OSDB server, ending their OSDB session

*Tags:* `OSDB`

### List services

> Returns descriptions of all services registered with the OSDB server.

*Tags:* `OSDB`

### Load service

> Loads a service description into the OSDB Service Registry

*Tags:* `OSDB`

### Unload service

> Removes a service description from the OSDB Service Registry

*Tags:* `OSDB`

#### Input Parameters
* `serviceId` - _required_ - Service ID of the service to be unloaded

### Describe service

> Returns a description of a given service

*Tags:* `OSDB`

#### Input Parameters
* `serviceId` - _required_ - Service ID of the service to describe.

## License

**flow**ground :- Telekom iPaaS / openlinksw-com-osdb-connector

Copyright © 2019, [Deutsche Telekom AG](https://www.telekom.de)

contact<EMAIL_ADDRESS>
All files of this connector are licensed under the Apache 2.0 License. For details
see the file LICENSE on the toplevel directory.


text:
# Jakarta migration

## Status

You can follow the status of the Jakarta migration in [the dedicated project tab](https://github.com/orgs/quarkusio/projects/13/views/20).

The build status is published in an [issue with a full report](https://github.com/quarkusio/quarkus/issues/25363).
Just scroll to the bottom for the latest.

## Testing

To test the Jakarta work, there are two approaches:

- Use the snapshots we publish nightly
- Build the `jakarta-rewrite` branch yourself

### Using snapshots

Snapshots of the `jakarta-rewrite` branch containing the transformed artifacts are published nightly on https://s01.oss.sonatype.org/content/repositories/snapshots/ .

Add the following snippet to your `pom.xml` to enable the s01 OSSRH snapshots repository:

```xml
<repositories>
    <repository>
        <name>s01 OSSRH Snapshots</name>
        <id>s01-ossrh-snapshots-repo</id>
        <url>https://s01.oss.sonatype.org/content/repositories/snapshots/</url>
        <layout>default</layout>
        <releases>
            <enabled>false</enabled>
            <updatePolicy>always</updatePolicy>
            <checksumPolicy>warn</checksumPolicy>
        </releases>
        <snapshots>
            <enabled>true</enabled>
            <updatePolicy>daily</updatePolicy>
            <checksumPolicy>fail</checksumPolicy>
        </snapshots>
    </repository>
</repositories>
```

The published artifacts have the `999-jakarta-SNAPSHOT` version so make sure to use this version in your projects.

### Build locally

Then you can build the `jakarta-rewrite` branch locally:

```
git checkout jakarta-rewrite
./mvnw -Dquickly
```

The installed artifacts have the `999-jakarta-SNAPSHOT` version so make sure to use this version in your projects.

## Transforming

This directory contains scripts and configuration files to automate the migration to Jakarta EE 10 soon.

This is a work in progress and some pieces are still missing (JPA 3.1 and Hibernate ORM 6 for instance).

### jakarta/transform.sh

`jakarta/transform.sh` is the main script to run.
It has to be run from the root of the Quarkus repository.

If you are offline and can't fetch the external projects, do:
```
export REWRITE_OFFLINE=true
jakarta/transform.sh
```
Obviously, you need to have run a full build before.
Also keep in mind you should run a full build from time to time to get the potential updates to OpenRewrite.

It consists of several steps that leverage various tools:

- [OpenRewrite](https://github.com/openrewrite/rewrite) - rewrites the POM files
- [Eclipse Transformer](https://projects.eclipse.org/projects/technology.transformer) - rewrites the classes

Note that this script also builds:

- A patched version of OpenRewrite (while waiting for integration of our patches)
- A patched version of the Rewrite Maven Plugin (to point to the patched OpenRewrite version)
- A patched version of the Kotlin Maven Plugin (to allow skipping the `main` compilation, it's required for the OpenRewrite run)

### Approach

#### OpenRewrite

The OpenRewrite transformation is done in one unique step to alleviate dependency issues we had before switching to this approach.
You don't need to run OpenRewrite for the modules you add to `transform.sh`, you just need to adjust the configuration.

OpenRewrite recipes are declared in the `jakarta/rewrite.yml` file.

Documentation for writing recipes can be found:

- In the [official documentation](https://docs.openrewrite.org/reference/recipes/maven)
- In the [source for those not already released](https://github.com/gsmet/rewrite/tree/main/rewrite-maven/src/main/java/org/openrewrite/maven) (things are very simple there and well documented in the source)

Recipes are not applied on all POM files, you need to declare the ones you want to apply to a given target POM when changes are necessary.
Note that in most cases, you don't need to apply any changes.

The active recipes have to be declared in the target POM with a `plugin` block in the `<build><plugins>` section similar to:

```xml
            <plugin>
                <groupId>org.openrewrite.maven</groupId>
                <artifactId>rewrite-maven-plugin</artifactId>
                <configuration>
                    <activeRecipes>
                        <recipe>io.quarkus.maven.javax.managed</recipe>
                        <recipe>io.quarkus.maven.javax.versions</recipe>
                        <recipe>io.quarkus.jakarta-versions</recipe>
                    </activeRecipes>
                </configuration>
            </plugin>
```

If you declare the `rewrite-maven-plugin` in a POM that is a parent POM, make sure the plugin is not inherited by adding `<inherited>false</inherited>` to the `<plugin>` block
as it's highly probable you don't want to apply the same rule to the child POM files:

```xml
            <plugin>
                <inherited>false</inherited>
                <groupId>org.openrewrite.maven</groupId>
                <artifactId>rewrite-maven-plugin</artifactId>
                <configuration>
                    <activeRecipes>
                        <recipe>io.quarkus.maven.javax.managed</recipe>
                        <recipe>io.quarkus.maven.javax.versions</recipe>
                        <recipe>io.quarkus.jakarta-versions</recipe>
                    </activeRecipes>
                </configuration>
            </plugin>
```

:warning: Not all recipes are equal and please be extremely careful when adjusting existing recipes.

In particular, be extremely care with the `io.quarkus.jakarta-versions` recipe:

- It is used for several POM files
- It shouldn't add any content that is not common to all these POM files (for instance, adding some new dependencies is forbidden as there is a good chance you don't want to add them in all the POM adjusted by `io.quarkus.jakarta-versions`)
- If you need to go further than just updating versions, create a specific recipe such as `io.quarkus.jakarta-jaxrs-jaxb`

#### Eclipse Transformer

The transformer phase is done at a more granular level but, typically, for now we transform the whole `extensions` subdirectory at once.
There's not much to say about this phase.
AFAICS, it just works.

### Experimenting

It is recommended to do the experiments in a separate copy of the Quarkus repository and:

- do the adjustments in a work branch of your original Quarkus repository, for instance `jakarta-work`
- commit in this branch
- then sync the branch and run the migration scripts in the separate `quarkus-jakarta` repository

That way, you can easily reinitialize your `quarkus-jakarta` copy after having attempted a migration.

Note that the `transform.sh` script replaces the `999-SNAPSHOT` version with `999-jakarta-SNAPSHOT` and will remove all `999-jakarta-SNAPSHOT` Quarkus artifacts that are in your local Maven repository.

You can for instance use the following approach:

- create a `quarkus-jakarta` copy of your `quarkus` repository
- add a `jakarta` remote to this `quarkus-jakarta` copy: `git remote add jakarta ../quarkus/`
- then you can run the following command to perform a full migration: `rm -rf ~/.m2/repository/io/quarkus && git checkout -- . && git pull jakarta jakarta-work && ./jakarta/transform.sh ; paplay /usr/share/sounds/freedesktop/stereo/complete.oga` (the last part plays a sound on Linux when done, if you use macOS, remove it)

repository: loicmathieu/quarkus

branch_name: refs/heads/main

gha_language: Java

repo_name: loicmathieu/quarkus


text:
# Orange Braised Pork Chops

My grandmother would often make these when we came to visit. She shared this recipe with me when I got married so that my husband and I could learn to make it together.

## Ingredients

- 6 loin pork chops, 1 inch thick
- 2 tablespoons flour
- 1/2 teaspoon salt
- 2 tablespoons oil
- 1 tablespoon light brown sugar
- 1/8 teaspoon ground ginger
- 1 tablespoon of orange zest
- 1 cup orange juice
- 1 cup orange sections

## Tools

- Large skillet
- Mixing bowl
- Mixing spoon
- Measuring cup
- Measuring spoons

## Method

1. Mix flour and salt together in a small bowl.
2. Wipe pork chops with a damp paper towel and then coat with flour and salt mixture.
3. Heat oil in a large skillet and then brown each side. 3-4 minutes per side.
4. Combine remaining ingredients expect the orange sections.
5. Reduce heat and pour mixture over pork chops. Simmer 45 minutes until tender.

## Tips

Keep an eye on pork as it cooks, thinner pork chops will cook faster. My grandma always used bone-in pork chops.

## Author

This recipe was contributed by Linnea Framnes


text:
Title: Lab 8: Bayesian Analysis using pyjags (+ Reinforcement Learning with gym)
Category: labs
Date: 2019-03-27
Slug: lab8
Author: Paul Tylkin and Vivek HV
Tags: R, bayesian, pyjags, gym, reinforcement learning

# Lab 8

### Slides
- [PDF](Presentation.pdf)

### Notebooks
- [Lab 8 Notebook](cs109b_lab8.ipynb)


text:
# cssi-2019-project-
An in browser puzzle.adventure game modeled after real life escape rooms.

PLOT:
In the distant future, in the wake of impending environmental catastrophe, all human beings upload their consciousnesses to a virtual world. Unfortunately for the player, their upload was unsuccessful, and they awake 10 minutes before their laboratory is scheduled to self-destruct. It's up to the player to hack their way into the virtual world before time runs out.

HOW TO PLAY:
Use the right and left arrow keys to look at different walls of the laboratory. Click on objects to interact with them.


text:
---
title: "Overview of IP Transfer Agreement"
author<EMAIL_ADDRESS>tags: ["Intellectual Property","aching","Contract Overviews","IP Transfer"]
date: 2017-09-06 11:13:18
description: "An IP Transfer Agreement is an agreement between an individual or corporation transferring its intellectual property to another individual or corporation."
---

### What is this document?

An IP Transfer Agreement is an agreement between an individual or corporation transferring its intellectual property (IP) to another individual or corporation.

### When would I use this document?

An IP Transfer Agreement can be used in a number of situations, including when a corporation is acquiring another corporation, founders are incorporating a business, and when a party is purchasing a product from another party.

### Who signs this document?

The party transferring its intellectual rights and the party receiving the transferred intellectual rights will both sign this document.

### More details about this document

The party transferring its intellectual property rights will often be called the “**Transferor**” and the party receiving the transferred intellectual property rights will often be called the “**Transferee**”.

The transfer of intellectual property rights is a permanent transfer and the Transferor will not have any more rights to its intellectual property. Intellectual property that may be transferred include: Domain name rights; trademark rights; patent rights; an invention; a business name; copyright and source code.

An IP Transfer Agreement can also include a release, where the Transferor agrees to not bring a claim against the Transferee for rights to the intellectual property.

An IP Transfer Agreement is in favor of the Transferee, since the Transferee will be receiving the rights to the Transferor’s intellectual property forever.

### What are the core elements of the document?

The core elements of an IP Transfer Agreement include: Definition of Intellectual Property; No Third Party Infringement; Release and Assignment.

Additional clauses may include: License to Non-Assignable Intellectual Property; Disclaimer; and Compensation.

### Related Documents:

**Employment Agreement** - an agreement setting out the terms of an employment relationship.

**Contractor/Consulting/Services Agreement** - this type of agreement can have various names, and is used when a person is paid to provide services but is not hired as an employee. Payment can be flexible (e.g. money, shares or some other form of compensation).

**Joint Venture Agreement** - an agreement for a joint business undertaking.

**Software Development Agreement** - an agreement for developing software.

**Asset Purchase Agreement** - an agreement for the sale of the assets of a business.

repository: clausehound/clausehound-blog

gha_language: TypeScript

repo_name: clausehound/clausehound-blog


text:
# [BoxCI](http://boxci.io) Puppet Cassandra Module

This is a Puppet module that provides the DataStax Enterprise Cassandra service.

### Intent

It is intended to be used by [BoxCI](http://boxci.io) but it can be used as a
normal Puppet module in general.

Being a [BoxCI](http://boxci.io) service module this service is configured so
that it is accessible from both inside the Guest (VM) as well as from the Host
machine.

### Supported OS

*Note:* This module currently only supports Ubuntu as currently
[BoxCI](http://boxci.io) supports Ubuntu images.

## Usage

To use this class add this as a submodule to your project at the mount point
`puppet/modules/dse_cassandra` and then simply declare it as follows:

```puppet
include dse_cassandra
```

## Contribute

We welcome contributions. If you would like to contribute follow the steps
below.

1. Fork the repo
2. Make a topic branch
3. Make your changes
4. Submit a pull request

repository: justinleveck/boxci-dse-cassandra-puppet

repo_name: justinleveck/boxci-dse-cassandra-puppet


text:
# Documentation
* [Library options](./options.md)

## Foreword
You may be wondering: "*Hey, why cannot I just use a simple visibility snippet like this:*"
```js
// Approximate code
function isElementInViewport(element) {
  const rect = element.getBoundingClientRect();

  return
    (rect.bottom > 0) &&
    (rect.right > 0) &&
    rect.left < (window.innerWidth || document.documentElement.clientWidth) &&
    rect.top < (window.innerHeight || document.documentElement.clientHeight);
}
```

Indeed, this and similar snippets are able to determine element's visibility. Moreover, a similar logic is used in Sentinel DOM for end-point areas comparison. However, these small snippets do not cover the following:

|   | Snippet | Sentinel DOM |
| - | -------- | ------------ |
| Performance | Performance optimization is up to you. | Analyzis is called only when the boundaries of the target are visible, otherwise no tracking is performed. A few other enhancements (i.e. throttling) shipped by default.
| Unique impressions | You need to create and maintain the logic. | Handled by internal `pool` variable, exposed to you inside the `callback` function. |
| Thresholds | Not complicated unless dealing with different scroll direction. | Handled automatically, regardless of scroll direction, resize and element animation.
| Tests | You need to write the tests to make sure tracking works as you expect. | All tests are written and maintained.

This, certainly, does not mean that you should not use these snippets. In some cases they may be more than enough, if the requirements towards tracking are plain and simple. However, from my experience, the latter may grow quite complex, yet somewhat repetitive.

I often find myself implementing the same things when providing visibility tracking for projects - handling unique impressions, custom thresholds and manual tracking (callback tracking), for example, for carousels. To prevent the repetition, I have decided to isolate my implementation into a library, which you and I can reuse for multiple projects and needs.

repository: kettanaito/sentinel-dom

repo_name: kettanaito/sentinel-dom


text:
### [CVE-2015-1195](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-1195)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

The V2 API in OpenStack Image Registry and Delivery Service (Glance) before 2014.1.4 and 2014.2.x before 2014.2.2 allows remote authenticated users to read or delete arbitrary files via a full pathname in a filesystem: URL in the image location property.  NOTE: this vulnerability exists because of an incomplete fix for CVE-2014-9493.

### POC

#### Reference
- http://www.oracle.com/technetwork/topics/security/bulletinapr2015-2511959.html

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
# Group Agreement

Our Team's Areas for Growth:

- Stay on track with team discussions - should not always be 100% personal conversations
- Understand personal work styles and preferences; communicate accordingly
- Understand each others' strengths and be able to have ownership over parts of project
- Learn to be vulnerable and to ask for help when needed

Our Team's Strengths:

- Commending others for their efforts and strengths
- Not being afraid to have confrontations when there is conflict - avoid passive aggressiveness
- Can't always control what happens, but you can choose how to respond - we're all on the same team
- Take risks! We should always try to push ourselves a bit.

Communication Plan:

- Slack Group
    - Check in once by day before 5:30pm; discuss if we decide to meet somewhere else or if we can't make it
    - Answer any outstanding questions within 24 hours

- Google Doc - Place to input ideas
- GitHub Projects - Our to-do list / kanban board

Conflict Resolution Plan:

- No diva rule.
- No passive aggressive behavior.
- Discussion is allowed for 20 mins, but if no resolution there will be a majority-rules vote.

Other agreements:

- Work/life balance > everything
- If super stuck on something, VOICE it! Don't spend more than half a day trying to figure something out.
- Will divvy up work based on what we feel comfortable with, while still challenging each of us in some way.
- TAKE BREAKS!

Git Process:

- At least one person should review each PR before merging.
- Will try separate tasks as much as posisble to avoid potential conflicts.
- If there are any conflicts, communicate with one another to ensure that the latest and greatest is being incorporated.
- Anytime you stop coding, A-C-P
- Always pull to local before you start coding
- Pull when starting group coding, and then pull when finishing group coding.
- When you have approved a significant merge, notify the group via Slack.

repository: bite-log/bite-log

repo_name: bite-log/bite-log


text:
wait(1) -- Run commands and wait with a spin
============================================

## SYNOPSIS

`wait` *commands* [`--spin`=*arc*|*star*|*pipe*|*ball*|*flip*|*mixer*|*caret*|*bar1~3*]

`wait` *commands* [`--time`=interval] [`--log`=file] [`--format`=format] [`--help`]

## DESCRIPTION

Run *commands* in the background and wait until the job has finished. Any output to standard error indicates `wait` to return `1`. While it waits, a customizable spinner is displayed in the command line.

## OPTIONS

* `-s --spin=style|string`:
    Set the spinner style. See `Styles` for styles and details on how to customize the spinner tokens.

* `-t --time=interval`:
    Set spinner transition time delay in *seconds*. A large value will refresh the spinner more slowly. You may use decimal numbers to represent smaller numbers. The default interval is `0.02`.

* `-l --log=file`:
    Write the standard error output to a given *file*.

* `-f --format=format`:
    Use the given *format* to display the spinner. The default format is `"\r@"` where `@` represents the spinner token and `\r` a carriage return, used to refresh (erase) the line.

* `-h --help`:
    Show usage help.

## STYLES

* arc, star, pipe, ball, flip, mixer, caret
* bar1~3

If no style is given, `mixer` is used by default. If you don't want to display any spinners, use `--spin=""`.

### CUSTOMIZATION

In addition to the default styles, you can specify a string of character tokens to be used each per spinner refresh cycle.

For example `--spin=12345` will display the numbers from 1 to 5, and `--spin=. --format=@` an increasing sequence of dots.

### PROGRESS BARS

Display a progress bar with a percent indicator using `--spin=bar1~3`:

* bar1: [=====] *num*%
* bar2: [#####] *num*%
* bar3: ....... *num*%

## EXAMPLES

Run commands in the background and display a spinning pipe while until finished.

```
wait --spin=pipe "curl -sS $URL"
```

Write the standard error output to *debug.txt*.

```
if not wait --spin=pipe --log=debug.txt "curl -sS $URL"
    return 1
end
```

## SEE ALSO

sleep(1)

repository: ViViDboarder/fisherman

repo_name: ViViDboarder/fisherman


text:
# Changelog

All notable changes to Sentinam will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [0.6.0] - 2021-03-22

### Added
- Add SqlStreamStore Persistence (https://github.com/bigjonroberts/Sentinam/pull/6)

## [0.5.2] - 2021-03-22

### Fixed
- Add Code Coverage Reports and Resolve Pack bug (https://github.com/bigjonroberts/Sentinam/pull/5)

## [0.5.1] - 2020-05-09

### Fixed
- Resolve Sourcelink Issues (https://github.com/bigjonroberts/Sentinam/pull/2)

## [0.5.0] - 2020-05-01

### Added
- This release contains core functionality
- Types and functions to easily generate Agents for processing common requests
- API is still very rough at this stage
[Unreleased]: https://github.com/bigjonroberts/Sentinam/compare/v0.6.0...HEAD
[0.6.0]: https://github.com/bigjonroberts/Sentinam/compare/v0.5.2...v0.6.0
[0.5.1]: https://github.com/bigjonroberts/Sentinam/compare/v0.5.0...v0.5.1
[0.5.0]: https://github.com/bigjonroberts/Sentinam/releases/tag/v0.5.0

repository: bigjonroberts/Sentinam

gha_language: F#

repo_name: bigjonroberts/Sentinam


text:
# Integrated Optoelectronic Oscillator designs in Photonic Integrated Circuit Technology - PIC

![](https://i.imgur.com/ePGrqcI.png)

Two designs for the generation of Microwaves using Photonic Integrated Circuit technology are presented in our work. The motivation behind this study is the use of low noise circuitry, unlike its analog counterparts.

[Poster](06.%20Integrated%20Optoelectronic%20Oscillator%20designs%20in%20Photonic%20Integrated%20Circuit%20Technology%20-%20PIC%20-%20-.pdf)
[Video](https://youtu.be/ML5x9xv6InE)

<br>

### Faculty Name

Mariya Wani

### Research Area

Photonic Integrated circuits/Microwave Photonics.

### Type of Work

Two novel concepts of an OEO design for telecommunication applications using Silicon Photonics technology have been designed.

### Current State of work

Simulation calculations and relative comparison between its analog counterpart on phase noise is done.

### Potential Applications

Telecommunication.

url: https://raw.githubusercontent.com/iiithf/rnd-showcase-2021/73339ad9c6a74cc86365ff2739a3652bad2f270b/CVEST/06. Integrated Optoelectronic Oscillator designs in Photonic Integrated Circuit Technology - PIC - -.md


text:
# LÖVE 11.x 3D example

An example of a rotating cube in 3d using [LÖVE](https://love2d.org) and [cpml](https://github.com/excessive/cpml).

Crate texture was found at [OpenGameArt](https://opengameart.org/content/3-crate-textures-w-bump-normal)


text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [1.0.0]

### Changed

- Upgrade null safety.

## [0.2.2]

### Fixed

- Fixed error message.

## [0.2.1]

### Fixed

- Separate cancellation processing and error processing for Android.

## [0.2.0]

### Added

- Separated cancellation processing and error processing.

## [0.1.0]

### Added

- Added support for iOS14.

## [0.0.5]

### Fixed

- Add error handling.

## [0.0.4]

### Fixed

- iOS13 createTemporaryURLforVideoFile.

## [0.0.3]

### Fixed

- Bug fix.

## [0.0.2]

### Fixed

- Remove files.

## [0.0.1]

- Initial release.


text:
# b2-uploader
Simple C binary to upload objects to BackBlaze's B2 buckets
Useful for simple programs which need to upload single files to B2.

# BUILDING
## NOTES
SecretString.h contains all private _user specific_ build information such as api keys and bucket name.
See `make Obfuscator` below to generate the APIKey string for use in b2UploadSec1 variable.

## Targets
`make` with no arguments will generate a Dev build which prints A LOT of debug info, including function names and code lines.
`make release` will generate a build which only prints errors, and does not have useful development debug information like function names or line numbers.

`make Obfuscator` generates the Obfuscator binary which is used to _securely_ encode your private key information into a "secret" string.


text:
title: Word Ladder
date: 2016-06-03 21:33:33
tags: Algorithm, BFS, Lintcode
---
[Question Link](http://www.lintcode.com/en/problem/word-ladder/)
##Intuition
it is first to build the distance matrix between each word and use shortest path algorithm to find the path from the start node to the destination.

##Problem
We assume we have N words, it needs O(N^2) to build the matrix and O(N^2) space to store the matrix. The length of word is L, therefore it is O(L*N^2) algorithm. Obviously it will be timeout for large test set.
##Solve
I notice that we only need the pair of words with 1 character difference. We only need build the adjacent list of such node that satisfy the criteria.
For the BFS, we can abandon the node when its current path is longer than the current shortest path.
However those optimization does not influence the time  and space complexity. Consequently it is still timeout for largest data set.

```c++
// compute the difference between pair of words
int dis(string w1,string w2){
    int diff = 0;
    for(int i = 0; i < w1.size(); i++){
        if(w1[i] != w2[i]){
            diff ++;
        }
        if(diff == 2){ // early stop
            break;
        }
    }
    return diff;
}

int bfs(unordered_map<int,vector<int> > &matrix, int start,int end, int n){
    int shortest = INT_MAX;
    queue< pair<int,int> > Q;
    Q.push({start,1});
    vector<int> visted(n,0);
    while(!Q.empty()){
        int cur = Q.front().first;
        visted[cur] = 1;
        int length = Q.front().second;
        if(length > shortest){ // early stop
            Q.pop();
            continue;
        }
        // find the destination
        if(cur == end && length < shortest){
            shortest = length;
            Q.pop();
            continue;
        }

        Q.pop();
        for(int i = 0; i < matrix[cur].size(); i++){
            if(visted[matrix[cur][i]] == 0){
                Q.push({matrix[cur][i],length + 1});
            }
        }
    }
    return shortest == INT_MAX ? 0 :shortest;
}
int ladderLength(string start, string end, unordered_set<string> &dict) {
    unordered_map<int,vector<int> > matrix;
    // write your code here
    int n = dict.size() + 2;
    vector<string> words(dict.begin(),dict.end());
    words.push_back(end);
    words.push_back(start);
    int startPos = words.size() - 1;
    int endPos = words.size() - 2;
    // build the adjacent list
    for(int i = 0; i < words.size(); i ++){
        vector<int> adj;
        for(int j = 0; j < words.size(); j ++){
            int c = dis(words[i],words[j]);
            if(c == 1){
                adj.push_back(j);
            }
        }
        matrix[i] = adj;
    }
    return bfs(matrix, startPos, endPos, n);
}
Why shell we change the way to search
```
```c++
// reference code from http://www.jiuzhang.com/solutions/word-ladder/
int ladderLength(string start, string end, unordered_set<string> &dict) {
    // write your code here
    if(start == end){
        return 1;
    }
    queue<string> Q;
    Q.push(start);
    dict.erase(start);
    int len = 2;
    while(!Q.empty()){
        int n = Q.size();
        for(int i = 0; i < n;i ++){
            string curr = Q.front();
            Q.pop();
            for(int j = 0; j < curr.size(); j ++){
                char pre = curr[j];
                // change the character to search
                for(char c = 'a'; c <= 'z';c++){
                    if(c == pre) continue;
                    curr[j] = c;
                    if(curr == end){
                        return len;
                    }
                    // O(1) to check
                    auto result = dict.find(curr);
                    if(result != dict.end()){
                        Q.push(*result);
                        dict.erase(curr);
                    }
                }
                curr[j] = pre; // change back
            }
        }
        len ++;
    }
    return 0;
}
```


text:
## Installation

You can install `js-core-data` using NPM:

```
npm install js-core-data --save
```

## Database module

Database libraries are not installed as dependencies. You need to install module for database you are planning to use.

- For SQLite
```
npm install sqlite3 --save
```

- For MySQL
```
npm install mysql --save
```

- For Postgres
```
npm install pg --save
```

## Create orm client

Create client with database url:

```
var CoreData = require('js-core-data');

var url = process.env.DATABASE_URL || 'sqlite://:memory:'; // :memory: identifies resource for sqlite in memory database

var database = new CoreData(url)
```

## Define model

js-core-data is ORM, so you need to define your entities. Easiest way is to creating directly on database client:

```
var database = ...;

var Book = database.createEntity('Book',{
    title: 'string',
    publishYear: 'int'
})

var Author = database.createEntity('Author',{
    firstname: 'string',
    lastname: 'string'
})

database.defineRelationshipOneToMany(Author, Book, 'books', 'author')
```

This is just simple example. For complete list of methods, attribute definition and versioning support see [Schema section](schema.md).

## Build table schema

When you have schema defined, you can sync database tables by running:

```
database.syncSchema().then(function(){
    console.log('done...')
})
```

## Insert data

Now you have everything set to start working with data. Everything is done in context, create one and insert/query entries.

```
var database = ...;

var context = database.createContext();

var book = context.create('Book',{title: 'The Da Vinci Code', publishYear: 2003})
var author = context.create('Author',{firstname: 'Dan', lastname: 'Brown'})

book.setAuthor(author)

context.saveAndDestroy().then(function(){
    console.log('all saved...now fetch')
})
```

## Fetch data

You can fetch data from database also with context.

```
context.getObjects('Book').then(function(books){
    // books variable contains array of Book entities
})
```

For more details visit [Fetching section](fetching.md).

## Next

Continue to [Contexts](contexts.md)

repository: jakubknejzlik/js-core-data

repo_name: jakubknejzlik/js-core-data


text:
# Cyber Discovery Community Discord Meta Repository [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Fcyberdiscovery%2Fmeta%2Fbadge&style=flat)](https://actions-badge.atrox.dev/cyberdiscovery/meta/goto)

This repository is for meta discussion of the Cyber Discovery [Discord server](https://discord.cyberdiscoverycommunity.uk).

## Code of Conduct

This repository is for serious suggestions to the server - we expect all suggestions and discussion to be made respectfully.

We welcome differing opinions and debate, but please make sure that this is done inoffensively. Be welcoming, inclusive, respectful, empathetic and constructive, and the whole process will be much smoother. 😄

## Usage

We understand that the meta repo can be somewhat confusing, so here's exactly how to use it:

### Making Issues

If you have any problems with the server, or aspects you think should be changed, make an Issue! Make sure no one has addressed the issue you have in another issue or PR before making it - if not, you can do the latter by:

1. Navigate to the `Issues` tab.
2. Click on the `New issue` button in the top-right corner.
3. Follow the template prompt and describe the issue.
Following comments and actions by the Admin Team or server members on the issue, one can then make a PR if a consensus has been achieved or the issue seems popular.

### Making PRs

For any suggestions, improvements, or solutions to current Issues, just make a Pull Request. Follow these steps:

1. Fork the `meta` repository.
2. Edit the necessary files for your issue on the fork.
3. Once done, navigate to the `Pull requests` tab.
4. Click on the `New pull request` button in the top-right corner.
5. Describe the changes you've made and submit it.

Discussion can then occur in this repository, among server members and admins on the PR created. After a PR has been approved by the Admin team, it will go into the Discord server to be voted on, to assess its popularity before potentially being implemented.

### Keep those suggestions coming in - the server can be improved with your ideas right here


text:
This February I took the plunge and decided to complete my Operating Systems class I signed up for last year. I’m currently in the last few weeks of the class and I'd like to share my 2 cents.

So here’s the deal, I think you should study Operating Systems. *But Why?* You may ask.

Here’s Why

Wait! Before I explain *Why*, I need to explain *What*.

## So What is an Operating System, anyway?

An Operating System is just another computer program! (If a large, complex, mature and mission critical one.) There! I said it.

More specifically, it’s a computer program that
-   multiplexes hardware resources and
-   implements useful abstractions.

*Wait, What?*

*Multiplexing:* allows multiple people or programs to use the same set of hardware resources—processors, memory, disks, network connection—safely and efficiently.

*Abstractions:* processes, threads, address spaces, files, and sockets—simplify the usage of hardware resources by organizing information or implementing new capabilities.

### Let's get a little deeper into abstractions.
Abstractions simplify application design by:
-   hiding undesirable properties,
-   adding new capabilities, and
-   organizing information.

Abstractions provide an *interface* (An interface describes what an computer program does, and how it interacts with the rest of the world.) to application programmers that separates *policy*—what the interface commits to accomplishing—from *mechanism*—how the interface is implemented.

I think an example would make things a little more clear. So let's take an example

### File
We all know what a File is, right?

I bet you're thinking, "What do you mean File? A File is a File!". We don't really think about Files anymore, do we?

Everything in a computer is File (I mean literally). From network sockets to your images, everything! Let's just say it's like an container where bunch of data goes.

Ok. So applying our abstractions's definition,

#### What undesirable properties do File Systems hide?

-   ##### Disks are just large arrays of non-volatile memory
    Disks have no concept of a file or file systems. They don't understand file names. Only thing they understand (over simplified) is to store/retrieve a bunch of data from a given location.

-   ##### Disks are slow!
    Yep. In-fact they are one of the biggest bottlenecks (And yes, your latest ssd with blazing fast speeds is still a huge bottleneck for a cpu) of a modern day computer. But, we don't care about that, right? We just want the file to be open as soon we click on it. We want our programs to start as soon as we click on it.

-   ##### Chunks of storage are actually distributed all over the disk.
    When you open any file (no matter it's size), you can see it in it's entirety. But underneath the hood, they are actually spread out all over the disk.

-   ##### Disk storage may fail!
    I know! It's the harsh truth. Your disk storage may fail. Disk drives have mechanical parts that can brake. The sectors in the plater of disk drive may die. And Yes your ssd can fail too. So, File Systems have features built into them that are designed to make Disks more Robust.

#### What new Capabilities do Files add?

-   ##### Growth and shrinking.
    We can easly grow or shrink a file. Imagine your reaction when you try to edit a file and your computer says you can't edit it any further. Yeah, You don't want that. File systems allow files to easly grow from say 4KB to say 4MB or even Terabytes. Or shrink them from Megabytes to kilobytes.

-   ##### Organization into directories.
    Guess what! There's no concept of directories on a disk. File System implements this notion of directories. Underneath the hood directories are just files containing entries for other files. But you don't need to know that. That's taken care for you by the file systems.

#### What information do Files help Organize?

-   ##### Ownership and permissions.
    Imagine if you created a file on your multi user computer. You wouldn't want any other user (say your sister or brother) to edit your file, would you? File Systems provide this notion of owenership and permissions.

-   ##### Access time, modification time, type, etc.
    File Systems provide other metadata about files such as access time, modification time, etc.

File Systems abstract away the Disks. That's their job. If you'd never heard (or had to take care about) any of the undesireable proprties I mentioned above (and there are lot more), File Systems have done their job well.

>   The essence of abstractions is preserving information that is relevant in a given context, and forgetting information that is irrelevant in that context.
>
>   – John V. Guttag

Oh My! that got a little out of hand. But, I think it's really important.

Ok. Now that it's out of the way, let's jump back to Why (which btw is really simple).

## Why study Operating Systems?

-   #### Reality:
    This is how Computers really work, and as a Computer Scientist or Engineer you should know how Computers really work.

-   #### Ubiquity:
    Operating Systems are everywhere and you are likely to eventually encounter them or their limitations.

-   #### Beauty:
    Operating Systems are examples of mature solutions to difficult Design and Engineering problems. Studying them will improve your ability to Design and Implement abstractions.

-   #### Design:
    Programming Operating Systems stresses the importance of careful Design and Specification before coding begins. You will learn the value of Design, probably the hard way.

-   #### Difficulty:
    Operating Systems are large existing code bases where new solutions have stringent performance requirements. While many Operating Systems concepts are elegantly simple, implementing them is not! Programming Operating Systems will make you a better programmer and improve all of your subsequent work.

-   #### Debugging:
    Debugging Operating Systems is challenging due to their multi- threaded nature and the lack of typical debugging support provided to applications. Again, Debugging Operating Systems will sharpen your debugging skills.

I hope I was able to convince you that Operating Systems are cool!

And you should at least appreciate them if not study.

>   akash

-   [source][0]

[0]:https://www.ops-class.org


text:
# Angular Inline Href

This directive provides a fix for hrefs in Firefox. Notably, when trying to reference an inline SVG, as so:

```html
<svg>
  <use xlink:href="#icon-back" />
</svg>
```

Because of the base tag, Firefox does not resolve the SVG symbol the way that you would expect. This directive simply
appends the current path to the href, making it an absolute URL.

You can use this directive with a string:

```html
<svg>
  <use inlineHref="#icon-back" />
</svg>
```

You can also use it with JavaScript:

```html
<svg>
  <use [inlineHref]="getBackIcon()" />
</svg>
```

The resulting tag will look something like this:

```html
<svg>
  <use xlink:href="http://www.myawesomesite.com/currentpage#icon-back" />
</svg>
```

## Setup

Perform the following steps to add this directive to your project:

1. `npm install --save ng-inline-href`
2. Import the directive into your shared module and add it to the `declarations` and `exports` arrays

```typescript
import { NgModule } from '@angular/core';
import { InlineHrefDirective } from 'ng-inline-href';

@NgModule({
  declarations: [ InlineHrefDirective ],
  exports: [ InlineHrefDirective ]
})
export class SharedModule {}
```

3. Import the shared module into your other modules to use the directive in your templates

## The Xlink Namespace

The `xlink` namespace on the SVG tag
[has been deprecated](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/xlink:href); however, browser support
is not great, so this directive includes the namespace.

repository: dattatraychaskar/ng-inline-href

repo_name: dattatraychaskar/ng-inline-href


text:
dotty linker
=====

Join the chat at [![Join the chat at https://gitter.im/lampepfl/dotty](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/lampepfl/dotty?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) and call for @Darkdimius if you have questions.

This is a modified version of Dotty compiler, that includes optimization phases.
Currently included phases are:
 - auto-specialization, enabled by passing `-lto:spec` or `-lto:all` flag;
 - rewrite rules, enabled by passing `-rewrites`.

# Rewrite rules
This a mechanism that allows to define custom optimizations alongside with a library. See this illustaration:
```scala
import dotty.linker._

@rewrites
object rules{
  // Library authors can define rewrite rules alongside with a library.
  // Rules are applied by a phase that runs after pickler. Thus they do not interact with type checking.
  // Rules can be defined in other compilation units, as they are discovered through TASTY.
  // The following examples are already working in my prototype:

  def isEmpty(x: Seq[Int]) =
    Rewrite(from = x.length == 0,               // linker will look for pattern in `from`, where method arguments are variables to be bound to trees
            to   = x.isEmpty)                   // if the pattern matches, it will rewrite it to `to`, replacing arguments with bound trees

  def twoDropRights(x: List[Int], a: Int, b: Int) =
    Rewrite(from = x.dropRight(a).dropRight(b), // multiple variables can be bound at once
            to   = x.dropRight(a + b))

  def bigIntShift(bi: BigInt, a: Int)(implicit evi: Literal[a.type]) =
  Rewrite(from = bi / a,
     to =
      if (Integer.bitCount(a) == 1) // one of those 2 branches will be eliminated either by Linker or by JIT as dead code
        bi >> java.lang.Integer.numberOfTrailingZeros(a)
      else bi / a
     )

  def twoFilters(x: List[Int], a: Int => Boolean, b: Int => Boolean)(implicit apure: IsPure[a.type]) =
                                                // implicits can be used to specify additional constraints.
                                                // my prototype currently supports IsPure and IsLiteral
                                                // IsPure is a tweaked check from tpd.
    Rewrite(from = x.filter(a).filter(b),
            to   = x.filter(x => a(x) && b(x)))

  def customFancyWarning(x: ParSeq[Int], x: (Int, Int) => Int) =
    Warn(pattern = x.reduceLeft(x)),            // custom warnings are also supported
             msg = “reduceLeft on parallel collection makes no sense”)

  def customFancyError(a: BigInt) =
    Error(pattern = a / 0,                      // custom errors are also supported
              msg = “This code is going to fail in runtime“)

  // the following examples are not _yet_ implemented in the prototype.

  def twoFiltersGeneric[T](x: List[T], a: T => Boolean, b: T => Boolean)(implicit apure: IsPure[a.type]) =
                                                // in case method takes type arguments, T becomes a similar type-variable to-be-bound.
    Rewrite(from = x.filter(a).filter(b),
            to   = x.filter(x => a(x) && b(x)))

  def metaExample[T](x: List[T])(implicit apure: IsPure[a.type]) =
                                                // in case method takes type arguments, T becomes a similar type-variable to-be-bound.
    RewriteMeta(from = x.toString,
            to = meta { /* entry point to interpreted scala-meta macros */})
}

object Test{
  def myPrettyPrint(a: Any): Unit = ()
  def main(args: Array[String]): Unit = {
     List(1,2,3).length == 0                    // will be rewritten to List(1,2,3).isEmpty
     List(1,2,3).drop(1).drop(1)                // will be rewritten to List(1, 2, 3).drop(2)
     List(1,2,3).dropRight(1).dropRight(1)      // will be rewritten to List(1, 2, 3).dropRight(1 + 1)
     List(1,2,3).filter(_ > 2).filter(_ > 1)    // will be rewritten to List(1, 2, 3).filter(x =>  _ > 2 && _ > 1)
     myPrettyPrint(args.length)                 // will be rewritten to println(“args.length” + “ = “ + args.length)
  }
}
```
# Auto specialization

Build a callgraph, sees which specializations are needed and generates only the required ones.
Enabled by `-lto:spec` or `-lto:all`.

For details, see

# Talks:
- [Scala Days 2015 Amsterdam](http://event.scaladays.org/scaladays-amsterdam-2015): Dotty Liker: Making your Scala applications smaller and faster
[\[slides\]](https://d-d.me/scaladays2015/),
[\[video\]](https://www.parleys.com/tutorial/making-your-scala-applications-smaller-faster-dotty-linker)
- [FlatMap 2016 Oslo](http://2016.flatmap.no/): AutoSpecialization in Dotty
[\[slides\]](https://d-d.me/talks/flatmap2016/)

repository: dotty-linker/dotty

branch_name: refs/heads/linker/public

gha_language: Scala

repo_name: dotty-linker/dotty


text:
---
title: "Making videos into GIFs on the command-line with gifify"
slug: making-gifs-command-line-gifify
published: true
layout: post
type: post
description: "Making gifs from videos using the command-line is easy using gifify."
redirect_to: "http://makerlog.org/posts/making-gifs-command-line-gifify"
---

I like making gifs.

You also probably like making gifs.

It's a thing we do.

On a regular basis I'll have video from television shows or movies or other video I've taken myself like screencasts that I want to turn into a gif.

Turning video into a gif can be done using online services, but I need a quick way to do it on the command line.

I've previously used this bash script: [gist.github.com/SlexAxton/4989674](https://gist.github.com/SlexAxton/4989674)

But I was excited to discover an npm module that was built for this purpose: [gifify](https://github.com/vvo/gifify)

It can be used on the command line _and_ as a Node module that supports streams.

## Installation

gifify has three dependencies:

- [ffmpeg](http://ffmpeg.org/)
- [imagemagick](http://www.imagemagick.org/)
- [giflossy](https://pornel.net/lossygif)

Here are instructions for installing those dependencies on a Mac:

### ffmpeg & imagemagick
You'll need [homebrew](http://brew.sh) if you don't already have it.

To install ffmpeg & imagemagick with homebrew run this command:

```
brew install ffmpeg & imagemagick
```

### giflossy

This tool for reducing image file size needs to be installed from the source.

I found that I needed to install automake before following the install instructions for giflossy:

```
brew install automake
```

Follow full instructions here: [github.com/pornel/giflossy#building-gifsicle-on-unix](https://github.com/pornel/giflossy#building-gifsicle-on-unix)

After following those install instructions you'll have a `gifsicle` command available.

### Install gifify

Now that we have the dependencies installed we can install gifify using npm:

```
npm install -g gifify
```

The `-g` option installs the package globally so that we can use its `gifify` command.

### Using gifify

The moment we've been waiting for: let's make a gif.

Here's the options for the command-line usage:

```
> gifify -h

Usage: gifify [options] [file]

  Options:

    -h, --help           output usage information
    -V, --version        output the version number
    --fps <n>            Frames Per Second, defaults to 10
    --from <position>    Start position, hh:mm:ss or seconds, defaults to 0
    --colors <n>         Number of colors, up to 255, defaults to 80
    --compress <n>       Compression (quality) level, from 0 (no compression) to 100, defaults to 40
    -o, --output <file>  Output file, defaults to stdout
    --resize <WxH>       Resize output, use -1 when specifying only width or height. `350x100`, `400x-1`, `-1x200`
    --speed <n>          Movie speed, defaults to 1
    --to <position>      End position, hh:mm:ss or seconds, defaults to end of movie
```

I found that with some videos I've needed to use the `gt-faststart` command that comes with ffmpeg on a video before the `gifify` command would work.

So I would first make a compatible video:

```
qt-faststart video.mov video2.mov
```

Then run `gifify`:

```
gifify video2.mov -o video.gif
```

Here's an example of a gif I made using gifify from the video of one of my first JavaScript games:

![jumpbud](/img/jumpbud.gif)

### gifify on GitHub:

[github.com/vvo/gifify](https://github.com/vvo/gifify)

### gifify on npm:

[npmjs.org/gifify](https://npmjs.org/gifify)