text:
---
id: configuration
title: Configuration Options
---

Our tooling supports the following types of configuration:

* [global properties](./global-properties.md)
  - properties with cross-cutting concerns which control generation, but  _don't_ belong to individual generators
  - Example: `debugSupportingFiles` prints the contents of template data bound to supporting files
* config options
  - configuration specific to each individual [generator](./generators/README.md)
  - these options are susceptible to validation within the defining generator; a config option of the same name across multiple generators may be validated differently in each
  - NOTE: The CLI accepts config options as "additional properties"
* additional properties
  - these are the properties which will be passed to templates
  - generally used to pass user-defined properties to custom templates
  - many config options may also be passed as additional properties, however generators will read/modify/rewrite config options
  - users may pass custom additional properties and use these within templates (e.g. a custom `generatedBy` key with a value of `Jim Schubert` for inclusion in a custom CVS-like header)
* top-level properties specific to individual tools/plugins used to bootstrap our tooling

## Tool-specific Declarations

The READMEs for the [CLI](https://openapi-generator.tech/docs/usage#generate), [Gradle Plugin](https://github.com/OpenAPITools/openapi-generator/tree/master/modules/openapi-generator-gradle-plugin), [Maven Plugin](https://github.com/OpenAPITools/openapi-generator/tree/master/modules/openapi-generator-maven-plugin), and [SBT Plugin](https://github.com/OpenAPITools/sbt-openapi-generator/blob/master/README.md) may have top-level or tooling specific options which appear to duplicate 'config options' or 'global properties'. Each may also expose user-facing properties slightly differently from the other tools. This may occur due to:

* Conventions used by the underlying tooling
* Limitations in underlying frameworks which define how properties must be declared
* Continuation of support for "legacy" invocation patterns
* Mistakes in documentation and/or contributions (please do [file a bug](https://github.com/OpenAPITools/openapi-generator/issues/new?assignees=&labels=Issue%3A+Bug&template=bug_report.md&title=%5BBUG%5D+Issue+with+options))

Take, for example, the CLI option of `--skip-validate-spec`. This flag sets the value to true with no option to set it to false (the default internally). The maven and gradle plugins allow for the top-level option `skipValidateSpec` to have a value of true or false. The SBT plugin, on the other hand, follows community convention and this property is `openApiSkipValidateSpec`.

_How_ you provide values to options also depends on the tool. OpenAPI Generator supports global properties for [selective generation](https://openapi-generator.tech/docs/customization/#selective-generation) -- such as `apis` -- to have either a blank value or a comma-separated list of selected values. We would define this in CLI as `--global-property apis` or `--global-property apis=Equipment`. In the Gradle Plugin, these properties are set directly as strings:

```
openApiGenerate {
    globalProperties.set([
        apis: "",
        models: "User:Pet"
    ])
}
```

In the Maven plugin, we're limited by XML syntax where `<apis/>` and `<apis></apis>` are treated the same as if the `apis` node was undefined; there's no way to provide an empty string as a default. Instead, we have to extract the global property into its own properties which maintain the two states supported elsewhere (i.e. "all apis" or "select apis"). We have `generateApis` which accepts a boolean and `apisToGenerate` which accepts a comma-separated selection list.

## Discovering Options

Refer to [global properties](./global-properties.md) for a list of available global properties and their usage.

Top-level tooling options are defined in [CLI usage](https://openapi-generator.tech/docs/usage/#generate). Many of these options directly map to camel case options in other tools, but do refer to [plugin documentation](https://openapi-generator.tech/docs/plugins) for full details or plugin-specific differences.

Config options for generators are available in [documentation online](https://openapi-generator.tech/docs/generators). You may also use the CLI to query config options for a target generator using `openapi-generator config-help -g <generator-name>`. For example:

```
$ openapi-generator config-help -g mysql-schema

CONFIG OPTIONS

	defaultDatabaseName
	    Default database name for all MySQL queries (Default: )

	identifierNamingConvention
	    Naming convention of MySQL identifiers(table names and column names). This is not related to database name which is defined by defaultDatabaseName option (Default: original)
	        original - Do not transform original names
	        snake_case - Use snake_case names

	jsonDataTypeEnabled
	    Use special JSON MySQL data type for complex model properties. Requires MySQL version 5.7.8. Generates TEXT data type when disabled (Default: true)

	namedParametersEnabled
	    Generates model prepared SQLs with named parameters, eg. :petName. Question mark placeholder used when option disabled. (Default: false)
```

This output provides the name of the configuration option. A set of acceptable values for any constrained values will print as an indented list (e.g. `identifierNamingConvention` above).

Suppose you want to apply snake case naming to mysql schema outputs. Your configuration might resemble the following examples.

**CLI**

```
openapi-generator -g mysql-schema -o out -i spec.yaml --additional-properties=identifierNamingConvention=snake_case
```

It may seem like a typo but there are two `=` signs in the above example.

**Maven Plugin**

```
<execution>
	<id>mysql-schema</id>
	<phase>generate-sources</phase>
	<goals>
		<goal>generate</goal>
	</goals>
	<configuration>
		<inputSpec>spec.yaml</inputSpec>
		<generatorName>mysql-schema</generatorName>
		<configOptions>
			<identifierNamingConvention>snake_case</identifierNamingConvention>
		</configOptions>
		<output>${project.build.directory}/generated-sources/mysql</output>
	</configuration>
</execution>
```

**Gradle Plugin**

```
openApiGenerate {
    generatorName.set("mysql-schema")
    inputSpec.set("$rootDir/spec.yaml")
    outputDir.set("$buildDir/mysql")
    configOptions.set([
            identifierNamingConvention: "snake_case"
    ])
}
```

repository: OpenAPITools/openapi-generator

repo_name: OpenAPITools/openapi-generator


text:
---
layout: project
title: "Skyscanner - Car Hire"
image: "/images/projects/car-hire/left-pane.jpg"
categories:
  - Miquido
tags:
  - Android
excerpt: ""
---

## Description

Car hire application extends core Skyscanner business. It is a car rentals price comparison tool allowing to get
the best car for selected features. Users can choose pick-up and drop-off location, car class, transmission type
and additional car equipment. Based on those choices several car rental agences are beeing queued.
{: style="text-align: justify;"}

Car hire application is available in more than 30 languages with built in right-to-left support.
For these languages layout direction is being changed accordingly.
{: style="text-align: justify;"}

## Libraries and frameworks

|       Android SDK      |       Java       |   Gradle  |
|         ORMLite        |       Gson       | Robospice |
| Universal Image Loader | Google Analytics |           |

## Preview

{% capture images %}
  {{ site.url }}/images/projects/car-hire/screen-1.jpg
	{{ site.url }}/images/projects/car-hire/screen-2.jpg
  {{ site.url }}/images/projects/car-hire/screen-3.jpg
{% endcapture %}
{% include gallery images=images caption="Phone screenshots" cols=3 %}

{% capture images %}
	{{ site.url }}/images/projects/car-hire/screen-4.jpg
	{{ site.url }}/images/projects/car-hire/screen-5.jpg
  {{ site.url }}/images/projects/car-hire/screen-6.jpg
{% endcapture %}
{% include gallery images=images caption="Tablet screenshots" cols=3 %}

Screenshots are based on a version <IP_ADDRESS>.5.

## Links

{: .badge}

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive


text:
# How does threading-profiler (the default mode) work

These blogs [skywalking-profiling](https://skywalking.apache.org/blog/2020-04-13-apache-skywalking-profiling/#profiling-in-production) and [skywalking-python-profiling](https://skywalking.apache.org/blog/2021-09-12-skywalking-python-profiling/) described how the threading-profiler works

And this figure demonstrates how the profiler works as well:

```mermaid
sequenceDiagram
    API->>+working thread: get: /api/v1/user/
    rect rgb(0,200,0)
    API->>+profiling thread: start profiling
    profiling thread->>working thread: snapshot
    profiling thread->>working thread: snapshot
    profiling thread->>working thread: snapshot
    profiling thread->>-working thread: snapshot
    end
    working thread-->>-API: response
```

It works well with threading mode because the whole process will be executed in **the same** thread, so the profiling thread can fetch the complete profiling info of the process of the API request.

# Why doesn't threading-profiler work in greenlet mode
When the python program runs with gevent + greenlet, the process would be like this:

```mermaid
sequenceDiagram
    API->>+working thread 1: get: /api/v1/user/
    rect rgb(0,200,0)
    greenlet.HUB-->>+working thread 1: swap in the profiled greenlet
    API->>+profiling thread: start profiling
    profiling thread->>working thread 1: snapshot
    working thread 1-->>-greenlet.HUB : swap out the profiled greenlet
    end
    greenlet.HUB-->>+working thread 1: swap in the other greenlet
    profiling thread->>working thread 1: snapshot
    greenlet.HUB-->>+working thread 2: swap in the profiled greenlet
    profiling thread->>working thread 1: snapshot
    profiling thread->>working thread 1: snapshot
    working thread 2-->-greenlet.HUB : swap out the profiled greenlet
    profiling thread->>working thread 1: snapshot
    profiling thread->>-working thread 1: snapshot
    working thread 1-->>-greenlet.HUB : swap out the other greenlet
    working thread 1-->>-API: response
```

In this circumstance, the snapshot of the working thread includes multi contexts of different greenlets, which will make skywalking confused to build the trace stack.

Fortunately, greenlet has an API for profiling, the doc is [here](https://greenlet.readthedocs.io/en/latest/tracing.html). We can implement a greenlet profiler to solve this issue.

# How the greenlet profiler works

A greenlet profiler leverages the trace callback of greenlet, it works like this:

```mermaid
sequenceDiagram
    API->>+working thread 1: get: /api/v1/user/
    rect rgb(0,200,0)
    greenlet.HUB-->>+working thread 1: swap in the profiled greenlet and snapshot
    working thread 1-->>-greenlet.HUB : swap out the profiled greenlet and snapshot
    end
    greenlet.HUB-->>+working thread 1: swap in the other greenlet
    rect rgb(0,200,0)
    greenlet.HUB-->>+working thread 2: swap in the profiled greenlet and snapshot
    working thread 2-->-greenlet.HUB : swap out the profiled greenlet and snapshot
    end
    working thread 1-->>-greenlet.HUB : swap out the other greenlet
    working thread 1-->>-API: response
```

We can set a callback function to the greenlet that we need to profiling, then when the greenlet.HUB switches the context in/out to the working thread, the callback will build a snapshot of the greenlet's traceback and send it to skywalking.

# The difference between these two profilers

The greenlet profiler will significantly reduce the snapshot times of the profiling process, which means that it will cost less CPU time than the threading profiler.

repository: apache/skywalking-python

gha_language: Python

repo_name: apache/skywalking-python


text:
Authentication in React Applications - Fork
====================================

This repo is forked from a really great tutorial - it belongs to this trail - https://vladimirponomarev.com/blog/authentication-in-react-apps-creating-components

*IMPORTANT* - The below content does not belong to me - it belongs to the source repo owner

Authentication in React Applications
====================================
The source code for a two-part tutorial for beginners who want to start to build applications using React and add an authentication layer to it. It was written for my blog, [https://vladimirponomarev.com](http://vladimirponomarev.com).

Parts of the tutorial
---------------------
1. [Creating Components](https://vladimirponomarev.com/blog/authentication-in-react-apps-creating-components) - in this part, we will create a basic application server, learn to bundle scripts using Webpack, get acquainted with basics of React (components, JSX syntax, props, states).
2. [Authentication Using JSON Web Token (JWT)](https://vladimirponomarev.com/blog/authentication-in-react-apps-jwt) - in this part, we will continue to improve the application and add authentication to it.

Screenshot
----------
![Authentication in React Applications](https://raw.github.com/vladimirponomarev/authentication-in-react-apps/master/screenshot.png)


text:
# Terraform::AWS::ElasticBeanstalkConfigurationTemplate

Provides an Elastic Beanstalk Configuration Template, which are associated with
a specific application and are used to deploy different versions of the
application with the same configuration settings.

## Properties

`Name` - (Required) A unique name for this Template.

`Description` - (Optional) Short description of the Template.

## See Also

* [aws_elastic_beanstalk_configuration_template](https://www.terraform.io/docs/providers/aws/r/elastic_beanstalk_configuration_template.html) in the _Terraform Provider Documentation_


text:
---
layout: post
title:      "Using CRUD with your API"
date:       2018-04-25 15:54:22 +0000
permalink:  using_crud_with_your_api
---

In your application controller, you will be writing paths to particular pages which sends or recieves information depending on the request you have written.

Example of a path is:

***get '/' do

erb :index

end***

usually this directs you to the index.html file as a homepage. However as you build your site there are going to be different pages that take on certain responsibilities. Depending on the CRUD method you want to use there are certain requests used in order to perform the desired actions.

Create -> POST request

Read -> GET request

Update ->  PATCH request

Delete -> DELETE request

What is an API? Its the part of the server that both, recieves and sends particular requests. For example, lets say you are looking up tickets on a ticket website. You find an event you want to go to and load up the page listing all the tickets that are for sale. By loading that page you using an API to reach out to the database and retrieve certain information you are asking for.   This is done by the use of GET in a application controller, which depending on the page you are on has access to specific information.

***get '/tickets' do

@tickets = Ticket.all

erb :ticket_listing

end***

In the ticket_listing page you would then be able to use the variable @tickets see all the tickets and depending on what attributes you have provided in the Tickets class you could see pricing, seat location, event_id and much more. This is very simple but can be expanded on when creating forms to submit via POST request which can find matching information a tickets table.

***post '/tickets' do

@tickets = Ticket.find_by(params[:event_id])

erb :ticket_listing

end***

The params[:id] is information that was submitted on a page using a form. This form is located on a different page where the user has ben prompt to select from available events. Upon selecting an event, this selection would have an event_id number that would be passed through the POST request and accessible via params. Params can contain a multitude of information so as to be specific you can specify what information you want by calling on the key from the hash you want. The variable @tickets would contain only the event with the same event_id and hone your results.

Update provides a way for you to change current information without having to delete and recreate it. There is another request called PUT which you can use but PATCH is much easier to to modify specific parts since you only have to send that information through. Using PUT you need to send the whole batch of params in order to change the information. Your form uses the POST method but in the input tag ***<input id="hidden" type="hidden" name="method" value="patch">*** you want your value="patch". This will allow you to use the following request on your application controller page.

***patch '/profile/:id' do

   @profile = Profile.find(params[:id])

    @profile.name = params[:name]

    @profile.birthday = params[:birthday]

    @profile.save

    erb :profile/:id

  end***

This lets you change any information you want and save the new values.

The last one is pretty straight forward, delete will simply take the object you select and perform an action to delete it from the database.

***delete '/profile/:id/delete' do

   @profile = Profile.find(params[:id])

    @profile.delete

    erb :deleted

  end***

extension: markdown


text:
# Changelog for flavorjones/irc-notification-resource

## v1.2.0 / 2019-02-01

Features:

* add a `debug` option [#8]
* emit `resource_version` in resource metadata [#7]

## v1.1.0 / 2018-12-11

Features:

* supports joining a channel before sending the message (off by default) [#4] (Thanks, @ercollin!)
* supports turning UseTLS off if you need to for your IRC server (still on by default) [#4] (Thanks, @ercollin!)

## v1.0.0 / 2018-03-27

Birthday!

repository: avanier/irc-notification-resource

repo_name: avanier/irc-notification-resource


text:
# Function
This example introduces how to define IO peripheral as SPI master port. OPL1000 only supports SPI master mode.

OPL1000 supports two SPIs port definition, SPI1 and SPI2. They can be 4 signal simple mode or 6 signal quad mode. SPI0 is reserved to access SPI flash device.

In this example IO2~IO5 4 pins are defined as SPI2 port simple mode.

In this Demo SPI0 access flash and SPI2 communicate with external SPI slave device examples are provided.

# Notes
- SP pin selection and work mode setting are defined by PinMux tool.
- PinMux tool is provided under Tool\PinMux folder.
- Refer Doc\OPL1000-pinmux-tool-user-guide.pdf to know how to use PinMux tool.
- Refer Doc\OPL1000-Flash-User-Guide.pdf to know how to program on board SPI flash.

gha_language: C


text:
Small application made with NodeJS, Express and JSON Web Token. In this app, we are testing routes with POST method by using Postman as a testing platform. Be sure to download Postman if you haven't already.

SETUP :

1. Clone this repo.

2. cd into project.

3. Do `npm install`.

4. Do `npm install nodemon -g` to have your NodeJS server automatically reload after every save.

5. Type `nodemon` in the console to run server.

6. Open Postman and test http://localhost:5000/api/login to generate token. Be sure to copy the value(without the semicolons).

7. In Postman, test another route http://localhost:5000/api/posts and in the Headers section, add `Authorization`, and for the value, add Bearer + token value. Example: Bearer testtokenvalue123. Click Send. In the Body section, the values should be displayed.

repository: MaxDrljic/JWT-Authentication

repo_name: MaxDrljic/JWT-Authentication


text:
[![Build Status](https://travis-ci.com/bprinty/auora.png?branch=master)](https://travis-ci.com/bprinty/auora) [![Code coverage](https://codecov.io/gh/bprinty/Flask-Occam/branch/master/graph/badge.svg)](https://codecov.io/gh/bprinty/Flask-Occam) [![Maintenance yes](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/bprinty/auora/graphs/commit-activity) [![GitHub license](https://img.shields.io/github/license/Naereen/StrapDown.js.svg)](https://github.com/bprinty/auora/blob/master/LICENSE) [![Documentation status](http://inch-ci.org/github/dwyl/hapi-auth-jwt2.svg?branch=master)](https://bprinty.github.io/auora)

# Auora

## Overview

There are currently several broadly-adopted alternatives to state management for JavaScript applications (e.g. [Redux](https://github.com/reduxjs/redux), [MobX](https://github.com/mobxjs/mobx), [Vuex](https://github.com/vuejs/vuex), [Effector](https://github.com/zerobias/effector)). Each provide a unique developer experience and enforce a specific paradigm for changing state and broadcasting updates to linked views/components.

### Why Make *Another* State Manager?

This package is an alternative approach to the same problem, attempting to take the best ideas from each alternative listed above (and provide some new ones). It's meant to provide an all-in-one solution with an intuitive API that can easily fit into any frontend framework.

It also tries to consolidate and simplify constructs from other state managers. In this state manager, the concept of `reducers` and `mutations` has been removed in favor of an internally managed transactional layer.

The code for this project was initially developed as part of an all-purpose (frontend and backend) [ORM](https://bprinty.github.io/vuex-reflect), but after use and iteration has evolved into it's own thing.

### How is this Library Different?

Unique features provided by this library that aren't readily available in other state management libraries include:

**No Mutations or Reducers**

Mutations do not need to be defined when stores are created. Committing mutations to the store happens in a more fluid way through `actions` or explicit `store` commits. However, they're still available to users comfortable with that pattern.

**State Transactions**

Actions dispatched from stores are automatically wrapped in a transaction so in-flight `state` changes don't affect store state if the action fails.

**tip Multi-Layered Hooks**

Users can subscribe to both global events (i.e. `commit`, `dispatch`, etc ...), and *specific* changes to state variables.

**Simpler Syntax**

Along with standard syntactic patterns, this module also supports a more fluid syntax for actions that allows users to call actions as functions instead of passing them as a string into `dispatch` calls.

**Framework-Agnostic**

This library was built to work with any front-end framework (or without one), and also has thorough [Examples](/examples/) detailing how to best use this library within the context of several popular frameworks.

Each of these core features is described in detail throughout the [Guide](/guide/) section of the documentation. For additional context on how to use this module in a front-end framework like [Vue](https://vuejs.org/) or [React](https://reactjs.org/), see the [Examples](/examples/) section of the documentation.

## Installation

### Install in Project

To use this library in a Vue project, add the package to your package dependencies via:

```bash
npm install --save auora
```

Or, with [yarn](https://yarnpkg.com/):

```bash
yarn add auora
```

### Use via CDN

To use this package via CDN, import it in your project via:

```html
<script src="https://unpkg.com/auora/dist/index.min.js"></script>
```

## Documentation

Documentation for the project can be found [here](http://bprinty.github.io/auora).

## Quickstart

To provide a quick and simple high-level picture of how this library can fit into a project, let's define a minimal **Store** and use that **Store** in a simple **Vue** application. We're going to define the `Hello World` of state management: a *counter* application.

### A Minimal Store

In our *counter* application, we're interested in managing the **state** of a `count` variable, and updating the state of that variable throughout our application in a way that will be reflected across components. Here is a dead-simple **Store** we can use for this example:

```javascript
import { Store } from 'auora';

const store = new Store({
  // state
  state: {
    count: 0,
    history: [0],
    operations: [],
  },

  // actions
  actions: {
    // sync
    increment({ state }) {
      state.count += 1;
      return state.count;
    },

    // async
    add({ state }, number) {
      return new Promise((resolve) => {
        state.count = state.count + number;
        resolve(state.count);
      });
    },
  },

  // events
  events: {
    dispatch(action, ...payload, { state }) {
      state.operations.push({ action, payload });
    }
  }

  // subscriptions
  subscribe: {
    count(newValue, oldValue, { state }) {
      state.history.push(state.count);
    },
  },

});
```

In this store, we've defined the following constructs:

* `state` - The global source of truth for data models in the application.
* `actions` - Synchronous or asynchronous processes that can change state.
* `events` - Callbacks that execute after specific *events* that happen throughout the state management lifecycle.

More information about the purpose for each of these constructs can be found in the [Guide](https://bprinty.github.io/auora/guide/) section of the documentation.

Outside of a framework, we can use the **Store** like so:

```javascript
store.state.count // 0
store.state.history // [0]
store.state.operations // []

store.apply.increment();
store.state.count // 1
store.state.history // [0, 1]
store.state.operations // [{action: 'increment', payload: []}]

store.reset('count');
store.state.count // 0
store.state.history // [0, 1, 0]
store.state.operations // [{action: 'increment', payload: []}]

store.apply.add(4).then(() => {
  store.state.count // 4
  store.state.history // [0, 1, 0, 4]
  store.state.operations // [{action: 'increment', payload: []}, {action: 'add', payload: [4]}]
});
```

### A Minimal Application

This library can be used within the context of any front-end framework, but let's use **Vue** to provide a concrete example of how it can easily augment front-end development. This package has several [Extensions](https://bprinty.github.io/auora/examples/) built to easily bind **Stores** to modern front-end frameworks

First, to bind our store from the previous section in a **Vue** application, we can use:

```javascript
// contents of index.js
import Auora from 'auora/ext/vue';

import counterStore from '@/store';

Vue.use(Auora);

const app = new Vue({
  el: '#app',
  store: counterStore
});
```

After binding the store, we can expose store **state**, **mutations**, and **actions** in components like:

```html
<template>
  <div>
    <p>{{ count }}</p>
    <button @click="increment">Increment Counter</button>
    <button @click="add(5)">Add 5 to Counter</button>
  </div>
</template>

<script>
export default {
  name: 'counter',
  store: {
    state: ['count'],
    actions: ['increment', 'add'],
  },
}
</script>
```

We can also access the store directly in components via:

```javascript
this.$store.count // 0

this.$store.apply.add(1).then(() => {
  this.$store.state.count // 1
});
```

That's it! For more information on state management or how to use different features of this plugin, see the [Guide](https://bprinty.github.io/auora/guide/) section of the documentation.

## Contributing

### Getting Started

To get started contributing to the project, simply clone the repo and setup the dependencies using `yarn` or `npm install`:

```bash
git clone git@github.com:bprinty/auora.git
cd auora/
yarn
```

Once you do that, you should be ready to write code, run tests, and edit the documentation.

### Building Documentation

To develop documentation for the project, make sure you have all of the developer dependencies installed from the `package.json` file in the repo. Once you have all of those dependencies, you can work on the documentation locally using:

```bash
yarn docs:dev
```

Or, using `vuepress` directly:

```bash
vuepress dev docs
```

### Running Tests

The [Jest](https://jestjs.io/) framework is used for testing this application. To run tests for the project, use:

```bash
yarn test
```

To have Jest automatically watch for changes to code for re-running tests in an interactive way, use:

```bash
yarn test:watch
```

To run or watch a specific test during development, use:

```bash
yarn test:watch -t model.update
```

Or, you can invoke `jest` directly:

```bash
jest
jest --watch
jest --watch -t model.update
```

### Submiting Feature Requests

If you would like to see or build a new feature for the project, submit an issue in the [GitHub Issue Tracker](https://github.com/bprinty/auora/issues) for the project. When submitting a feature request, please fully explain the context, purpose, and potential implementation for the feature, and label the ticket with the `discussion` label. Once the feature is approved, it will be re-labelled as `feature` and added to the project Roadmap.

### Improving Documentation

Project documentation can always be improved. If you see typos, inconsistencies, or confusing wording in the documentation, please create an issue in the [GitHub Issue Tracker](https://github.com/bprinty/auora/issues) with the label `documentation`. If you would like to fix the issue or improve the documentation, create a branch with the issue number (i.e. `GH-123`) and submit a PR against the `master` branch.

### Submitting PRs

For contributors to this project, please submit improvements according to the following guidelines:

1. Create a branch named after the ticket you're addressing. `GH-1` or `bp/GH-1` are examples of good branch naming.
2. Make your changes and write tests for your changes.
3. Run all tests locally before pushing code.
4. Address any test failures caught by [Travis CI](https://travis-ci.com/bprinty/auora).
5. Make sure you've updated the documentation to reflect your changes (if applicable).
6. Submit a PR against the `master` branch for the project. Provide any additional context in the PR description or comments.

### Keeping up to Speed on the Project

All development efforts for the project are tracked by the project [Kanban](https://github.com/bprinty/auora/projects/1) board. Contributors use that board to communicate the status of pending, in-progress, or resolved development efforts. If you have a question about the Roadmap or current in-progress issues for the project, see that board.

repository: bprinty/auora

gha_language: JavaScript

repo_name: bprinty/auora


text:
### Description:

All programs perform a  _hand coded_ Gaussian elimination with partial pivoting, except those
in
C++Lib/, PyScipy/ and JuLib/ which call the Lapack and blas libraries  to perform
a LU factorization; in any case, the cost is similar in term of operations counts.

### Motivation:

The  Gaussian elimination with partial pivoting, even if this is something one
should not code in the real life (except for pedagogical purpose) seems to be
a good prototype of numerical algorithm an user would like to code (as it uses
about n^3 floating point operations and array manipulations).

### Authors:

Thierry Dumont<EMAIL_ADDRESS>
Benoît Fabrèges<EMAIL_ADDRESS>
Roland Denis<EMAIL_ADDRESS>
### The directories contain:

- **C++**:      pure C++, sequential.

- **C++Lib**:   C++ and lapack + openblas.

- **Ju**:       pure Julia

- **JuLib**:    Julia +  lapack + openblas.

- **Py**:       pure Python

- **PyVec**:    pure Python, vectorized.

- **PyScipy**:  Python + Scipy.

- **Pythran**:  Pythran.

- **PythranVec**: Pythran vectorized

- **Numba**:    Python + Numba

- **Results**:    graphical material and an example of result.

### Note:

* Concerning C++Lib/,  JuLib/ and PyScipy/ all of them call lapack  material and
blas which probably will be openblas. For large matrix sizes, with openblas, the
called routines would possibly be multithreaded at least in some cases (see
PLOT/Benchmark/kepler.pdf, for which C++Lib is multithreaded).

* Concerning the random number generator: we use a very poor
generator -and not a genarator provided by any language dependent
library- only because we want to be sure (and we actually checked
this) than the "random" sequences generated are identical in all
languages. Actually, we are not interested in "good" random sequences.

### Running the benchmarks

cd succesively in C++, Ju, Py, Numba, Pythran, PyVec, C++Lib, JuLib,
PyScipy PythranVec; then look at the documentation.

#### Results:

Running the codes  will create a file named:  RunningOn"your
hostname".

### Ploting results:

cd PLOT/

Read README.md file.

### Results:
Have a look at the  [this page in the Wiki](https://github.com/Thierry-Dumont/BenchmarksPythonJuliaAndCo/wiki/3-The-Gaussian-Benchmark).

repository: fluiddyn/BenchmarksPythonJuliaAndCo

repo_name: fluiddyn/BenchmarksPythonJuliaAndCo


text:
# Arcade Game Project

**Arcade Game** is a interactive HTML5 & JavaScript game.

## Game description

In this game the player objective is to get the highest score by collecting Gems and reaching higher levels.
But it won't be easy: there'll be some enemies on the road that you'll have to dodge!
The enemies will become faster as the player wins the levels.

## Game Over

If the player collides with the enemies 3 times, it'll lose all of his hearts and die.
The player then can decide to start a new Game by hitting the **RETRY** button.

## Scoring Points

The player can score points by:

 1. Reaching the sea: **300 points**
 2. Collect a gem: **200 points**

The score will be reset to 0 if the player dies.

## How to move the character

The player character can move using the arrow keys (←, →, ↓, ↑).

## Game load

The game needs the [app](js/app.js), [engine](js/engine.js) and [resources](js/resources.js) files to load correctly.

## Licence

MIT


text:
---
layout: post
title: "Sample Table: ArcelorMittal Earnings Snapshot"
author: Analyst N0.1, Analyst No.3
categories: fa
---

Conducting fundamental analysis requires calculating a firm's "fair value" by applying methods like Discounted Cash Flow to data tables, so this post demonstrates how an earnings table looks like.

At 1AM EST, May 6th, Luxembourgish steel corporation ArcelorMittal **(NYSE/Euronext: MT)** reported astounding earnings for the first quarter of 2021. Spurred by Biden administration's infracture plans and pent-up demand caused by COVID-19, steel futures seem to be taking off into a new super cycle, generating great returns for investors of international steel giants like MT.

### ArcelorMittal 2021 Q1 Earnings Snapshot (in million USD)

Categories | 21'Q1 | 20'Q4 | 20'Q1
--- | --- | --- | ---
Sales | 16,193 | 14,184 | 14,844
Operating Income | 2,641 | 1,998 | -353
Net Income | 2,285 | 1,207 | -1,120
Earnings Per Share | 1.94 | 1.01 | -1.11
EBITDA | 3,242 | 1,726 | 967

### ArcelorMittal 2021 Q1 Production Snapshot (in million ton)

Categories | 21'Q1 | 20'Q4 | 20'Q1
--- | --- | --- | ---
Crude steel production | 17.6 | 18.8 | 21.1
Steel shipments | 16.5 | 17.3 | 19.5
Own iron ore production | 13.3 | 15.3 | 14.4
Iron ore shipped at market price | 9.8 | 10.6 | 8.6

repository: JasonBourbaki/final-project-theme

repo_name: JasonBourbaki/final-project-theme


text:
# backend-task

The task is implemented with node.js and express.js.

Few Assumptions :

* Total points in the system are always greater than deduct amount.
* Transactions with previous timestamps are not added to system / not considered valid (for performance purpose). If want to consider valid remove comment for this line.
* Whenever a transaction with -ve value is added, System internally call deductTransaction method.

To run the app :
* cd backend-task
* node index.js

To test the app we can use postman:

* Add Points :

![Add Points](https://user-images.githubusercontent.com/29951473/106351556-eebbd800-6291-11eb-827f-7a74eb30c8c1.png)

* Deduct Points :

![Deduct Points](https://user-images.githubusercontent.com/29951473/106351555-ee234180-6291-11eb-88b1-32a16d122a24.png)

* Check Balance :

![Check Balance](https://user-images.githubusercontent.com/29951473/106351558-efed0500-6291-11eb-894a-256504caf744.png)

Console Output:

![Screenshot (202)](https://user-images.githubusercontent.com/29951473/106351557-ef546e80-6291-11eb-9f09-2f7bab71a822.png)

branch_name: refs/heads/main


text:
---
layout: post
image: /xapi-intro-guide.png
tags: [learning-technologies-cat]
resource-url: http://www.yetanalytics.com/xapi-an-introductory-guide-ebook
access: Requires Email
resource-type: Ebook
resource-author: Margaret Roth
resource-org: Yet Analytics
title: "xAPI: An Introductory Guide"
---
{% include JB/setup %}

Consider this introductory e-book a crash course – everything you'll need to know to have a basic understanding of the Experience API™, otherwise known as xAPI. xAPI is an open data interoperability specification originally developed to get a better picture of how, when, and why learning happens both on and offline.


text:
# `@hex-engine/core`

This package provides the core Entity and Component system used in [Hex Engine](https://github.com/suchipi/hex-engine).

It is built such that it can be used for any render target; 2D, 3D, etc.

For more information, please check the main README for [Hex Engine](https://github.com/suchipi/hex-engine).

repository: suchipi/hex-engine

gha_language: TypeScript

repo_name: suchipi/hex-engine


text:
# Progress_bar
A simple progress bar feature for Julia codes. It's a simple function that uses unicode characters to create the progress bar. The code is in a function form. So, it can be easily included in any julia codes/notebook.

# Usage
Copy-paste the function progress_bar() into your jupyter notebook. Compile/run it. Then just call it from your main program/function/loop.

The program can also be run as an external funciton. Copy-paste the code function in a new file and rename it as progress_bar.jl.

## Main function
```julia
# Input arguments:
# current_step = current position in the loop. Use the loop index.
# total_step = total number of steps in your loop. Note that it is assumed that the loop starts from 1 and ends at total_step.
# Nbar = how many blocks you want to include in the progress bar.

# Progress_bar function.
# To use as a separate file: Should be added as a progress_bar.jl file in the same folder as your code. In the main code, use: include("progress_bar.jl");
# To use in Jupyter notebook, just include the funciton in a cell and run it.

# Input arguments:
# current_step = current position in the loop. Use the loop index.
# total_step = total number of steps in your loop. Note that it is assumed that the loop starts from 1 and ends at total_step.
# Nbar = how many blocks you want to include in the progress bar.

function progress_bar(current_step,total_step,Nblock)

    percentage = round(current_step*100/total_step,1);     # Calculate percentage completion

    print("\r")
    if current_step == 1
        print("Progress = 0.0\% ");
        for i = 1:Nblock
            print("\u2591");                      # Use the unicode character "light shade" to create the empty progress bar.
        end
        print("\r");
    end

    print("Progress = ",percentage, "\% ");         # Print percentage completion

    for i = 1:round(percentage*Nblock/100)        # Map the progress percentage to a 1 to Nblock grid.
        print("\u2593");                          # Use the unicode character "dark shade" to fill the progress bar.
    end

end

```

## Testing
The code can be tested using the following test program:

```julia
# Test program.

max_count = 40;    # define maximum count of the loop
Nblock = 20;       # number of blocks in the bar plot

for i = 1:max_count
    progress_bar(i,max_count,Nblock);

    for k = 1:5e6    end   # delay loop. sleep() command causes some unexpected issues.

end
```

If the delay between two successive calls of the progress_bar() function is very small, then the code can cause some problems. To solve this, we can include a check condition to make sure that there is a minimum time interval between two successive function calls. The following test code uses 100ms as the minimum time interval:

```julia
# An improved code to test the progress_bar function. June 2018.
# The time checking makes sure that the progress_bar() function is not called within
# a very short time. Current interval is set at 100ms.
# This pause between successive calls helps to display the progress bar properly.

max_count = 45;    # define maximum count of the loop
Nblock = 20;       # number of blocks in the bar plot
t1 = 1000*((60*Dates.hour(now()) + Dates.minute(now()))*60 + Dates.second(now())) + Dates.millisecond(now());

for i = 1:max_count
     t2 = 1000*((60*Dates.hour(now()) + Dates.minute(now()))*60 + Dates.second(now())) + Dates.millisecond(now());

     if (t2 - t1 > 100)  || (i == max_count)                       # if ellapsed time > 100ms, then print progress bar
        progress_bar(i,max_count,Nblock);
        t1 = copy(t2);
    end

    for k = 1:5e6    end   # delay loop. sleep() command causes some unexpected issues.

end

```

Note that for slow running loops (those are the cases where the progress_bar is especially necessary), the first simple version of the test code works fine.

# Preview
Progress = 32.5% ▓▓▓▓▓▓░░░░░░░░░░░░░


text:
# UART DPI with pseudo-terminal

This module is a SystemVerilog module with a UART interface
(`tx`/`rx`). It used DPI to start a pseudo-terminal (`/dev/pts/<n>`)
that can then be opened with a terminal program.

There can be multiple instances of this module in a design, each with
its own pseudo-terminal.

## Testbench (echo)

### Vivado xsim

    cd tbench/xsim
    make sim

repository: wallento/uartdpi

repo_name: wallento/uartdpi


text:
# Flumina

A parallel programming model for online applications with complex synchronization requirements.
Also known as *dependency-guided synchronization (DGS).*
Flumina can used for *stream processing* workloads and is evaluated against [Flink](https://github.com/apache/flink) and [Timely Dataflow](https://github.com/TimelyDataflow/timely-dataflow).

For more information about Flumina, check out our PPoPP'22 paper:

- **Stream Processing with Dependency-Guided Synchronization.** Konstantinos Kallas, Filip Niksic, Caleb Stanford, and Rajeev Alur. Principles and Practice of Parallel Programming (PPoPP), February 2022.
[Extended version](https://arxiv.org/abs/2104.04512).

## Installation and basic tests

1. Install Erlang: [link](https://www.erlang.org/downloads) or follow [this guide](https://medium.com/erlang-central/erlang-quick-install-9c5dcaa5b634)

**NOTE:** We have tested running the code with Erlang 23 and Erlang 24. If installation is not working, make sure you have one of these two versions installed.

2. Set your environment variable `ERL_TOP` where your Erlang OTP
installation is. If downloaded using apt, then it should be in
`/usr/lib/erlang/`. On mac, if downloaded using homebrew, then it should be in `/opt/homebrew/lib/erlang/`; otherwise also check `/opt/local/bin/to_erl/`.
E.g. (replacing the path with the correct directory for your installation):
```
export ERL_TOP=/usr/lib/erlang/
```

3. Set `FLUMINA_TOP` to the `flumina` directory.
(in the top-level directory, run `echo $PWD` to get the full path.)

4. Run `make` to build Flumina.

5. Run `cd experiments` directory: run `make` there to build the Flumina experiments (note: for baseline comparison, the Flink and Timely developments are built separately and not handled by this makefile).

6. Finally, still in `experiments`, run `make tests` to run tests. You should see output like this:
```
mkdir -p logs
  All 203 tests passed.
  All 420 tests passed.
  All 200 tests passed.
```

## "Hello, World" example

After having built the experiments and running the tests, you can run the "Hello, World" Flumina example.

You can inspect the source code of this example in `abexample.erl`. The function that configures it is called `big_conf/3` (https://github.com/angelhof/flumina-devel/blob/master/experiments/examples/abexample.erl#L91).

It roughly sets up the following:
- Sets three input streams and their rates, two fast streams for `a` tags, and one slow stream for `b` tags.
- It then invokes the compiler to generate a synchronization plan for these input streams.
- It then spawns three producers for these streams, and runs the synchronization plan.

You can run this example by running `make abexample` in `experiments`. The output will look something like this:
```
Mod: abexample, Fun: big_conf, Opts: [...]
Dependency Graph:
[{{b, ...},{{a,2}, ...}},
 {{{a,2}, ...},{b, ...}},
 {{b, ...},{{a,1}, ...}},
 {{{a,1}, ...},{b, ...}}]
Root tree:
{{[{b, ...}], ...},
 [{{[{{a,2}, ...}], ...},[]},
  {{[{{a,1}, ...}], ...},[]}]}
Possible setup trees: 1
Configuration:
...
Spawning 'steady_retimestamp' producer forimpl tag: ...
Spawning 'steady_retimestamp' producer forimpl tag: ...
Spawning 'steady_retimestamp' producer forimpl tag: ...
Producer for implementation tag: {{a,1}, ...} is done initializing.
Producer for implementation tag: {{a,2}, ...} is done initializing.
Producer for implementation tag: {b, ...} is done initializing.
Configuration done
{'EXIT',<0.83.0>,normal}
{sum,{{b,1000},2}}
{sum,{{b,2000},13}}
...
```

The output contains the implementation tag dependence graph produced by the dependencies of the input tags, a root tree (which is a simplified version of a synchronization plan), and a synchronization plan (which is called configuration).

It then spawns producers, and starts running the experiment.

## Notes on the experiments

The most recent experiments for Flumina and baselines were run using Amazon AWS EC2 instances,
with a large amount of custom scripting and work to set up correctly.
Some local versions can be run, but the full experimental setup would be difficult to replicate.
For example, clocks have to be synchronized across AWS instances, and this was done by running a Chrony script on all instances (`scripts/setup_chrony.sh`).
Most of the other experiment scripts for Flumina, Flink, and Timely are in `timely/scripts`.
This repository also contains some outdated and not-maintained infrastructure for running experiments using the NS3 network simulator and using Docker instances.

The Flink experiments are contained in `/experiments/flink-experiment` (with relevant scripts in `experiments/scripts` and in other directories).
Unfortunately, we do not have instructions for the Flink experiments at this time (but feel free to post a GitHub issue for your use case, see below).

## Running the Timely experiments locally

The Timely experiments are in `/experiments/timely-experiment` (also with relevant scripts in `experiments/scripts`),
and they are shipped with a usable CLI.
Inside that directory, run `cargo build` or `cargo build --release`,
then `cargo run` or `cargo run --release` for the CLI.
Be warned that Timely is MUCH faster in release mode for all queries,
so the `--release` flag is critical for performance experiments.
A short demo of the CLI:

- The experiments are organized into different examples: `fd` is the fraud-detection example, `vb` is the value-barrier example, and `pv-good` and `pv-bad` are two different implementations of the page-view example. Each command will describe its options if you try running it. For example, running `cargo run --release vb` gives the following expected parameters:
```
<val-rate-per-milli>
<vals-per-hb-per-worker>
<hbs-per-bar>
<exp-duration-secs>
<workers>
<nodes>
<this-node>
```
  OPTIONAL ADDITIONAL PARAMETER: a final parameter can be added to run multiple experiments in parallel: `s` for single process (default), `l` for multiple nodes locally, and `e` for running with multiple nodes on EC2.

  The most important parameters are the last 4: how long the experiment should run, how many workers and nodes to run (if nodes is more than one, you need to open more than one shell and run on each node), and which node this is (between 0 and number of nodes). For example, here's a plain single-threaded experiment, run for 5 seconds:
```
cargo run --release vb 1 10 10 5 1 1 0
```
  The experiment returns with the latency and throughput measurements of the experiment. It can also be run with two workers (threads):
```
cargo run --release vb 1 10 10 5 2 1 0
```
  where the throughput, as expected, doubles, and the latency may go up a bit. Finally it can be run with two processes locally, in two different shells, with two workers each:
```
# [in first shell]
cargo run --release vb 1 10 10 5 2 2 0 l
# [in second shell]
cargo run --release vb 1 10 10 5 2 2 1 l
```

- `exp1`, `exp2`, etc. are pre-set experiments (hardcoded in `main.rs`) which basically run the above for different numbers of workers and numbers of nodes and calculate a whole bunch of different throughputs.

- Finally, The `-gen` versions are experiments which run data generation only, with no data processing.
They can be useful to see what the input looks like, e.g.:
```
cargo run --release vb-gen 1 10 10 1 1 1 0
```

## Issues

This is a research prototype implementation in Erlang and is not currently being maintained. However, if you encounter any issues running the code, please post an issue on GitHub and we will try to take a look.

repository: angelhof/flumina

repo_name: angelhof/flumina


text:
# linter-python package

Plugin to lint python files. Whole logic based on pylama and pylama-pylint applications.

![Package usage](https://raw.githubusercontent.com/pchomik/linter-python-doc/master/img/example.gif)

## Requirements

* python >= 2.7
* pylama >= 7.3.3
* pylama-pylint (optional)

## Atom linters

* [Atom Linters](http://atomlinter.github.io/)

#### Linters for python

* [linter-python](https://atom.io/packages/linter-python)
* [linter-pep8](https://atom.io/packages/linter-pep8)
* [linter-pydocstyle](https://atom.io/packages/linter-pydocstyle)
* [linter-flake8](https://atom.io/packages/linter-flake8)
* [linter-pylama](https://atom.io/packages/linter-pylama)

## Plugin installation

#### Atom plugin installation

![Package usage](https://raw.githubusercontent.com/pchomik/linter-python-doc/master/img/install.gif)

* Go to Settings -> Install
* Type "linter-python"
* Press "Install"

#### Pylama installation

```
pip install pylama pylama-pylint
```

If pip is something new for you please look [here](https://pip.pypa.io/en/stable/installing/) for more detail.

## Plugin configuration

#### Basic plugin configuration

![Package usage](https://raw.githubusercontent.com/pchomik/linter-python-doc/master/img/config.gif)

* Go to Settings -> Packages
* Type "linter-python" and go to plugin settings
* Set path to pylama binary e.g. /usr/bin/pylama
* Select needed pylama options

#### Options added in 3.0.4 version

![Package usage](https://raw.githubusercontent.com/pchomik/linter-python-doc/master/img/3.0.4.gif)

* Atom API was used to select error
* URL to error description

#### Plugin configuration vs. performance

Please be informed that plugin has to create temporary files to lint file in the fly. In case of any performance issues please try
to change trigger option to "File saved". For such option temporary files are not needed.

## Pylama related topics

#### Pylama results depend on plugin order

It was discovered that pylama plugin order may change lint results. Issue is under investigated and will be reported
to pylama project as soon as I get time to create test scenarios.

Tests show that the most trusted configuration is: mccabe,pyflakes,pylint,pep8,pep257

#### Pyflakes plugin may change pylama result

New issue was created in pylama project. Pylama results are not constant when pyflakes plugin is enabled. Issue is visible with Python 3.5.1

Issue details are available [here](https://github.com/klen/pylama/issues/67).

## Lint errors

Starting from plugin version 3.0.0 lint output provides link to error description available on GitHub [project](https://github.com/pchomik/linter-python-doc/blob/master/errors/).

Thanks to @linickx who created all pages. Please provide more pull requests if you like to create single place for all python defined errors.

## Contribution

Pull requests, issues, issue investigation, reviews are more than welcome.

## Contributors

* @linickx
* @Arcanemagus
* @Zebradil

## License

Package license is available [here](https://raw.githubusercontent.com/pchomik/linter-python/master/LICENSE.md)

## Contact

Please create issue in case of any question or feature request.

## Changelog

This section contains changes from last 3 releases.

Full list of changes is available [here](https://raw.githubusercontent.com/pchomik/linter-python/master/CHANGELOG.md)

#### 3.1.2
* (#37) Fix issue: Cannot read property 'getPath' of undefined

#### 3.1.1
* Update release notes and readme file

#### 3.1.0
* (#31) Execution finished with error because of pylama exit code change

#### 3.0.5
* (#28) Add cache functionality
* (#25) Remove underline options from plugin configuration
* (#27) Documentation update
* (#26) Regenerate new plugin exaples

repository: pchomik/linter-python

repo_name: pchomik/linter-python


text:
# no-arguments-for-html-elements

✅ The `extends: 'recommended'` property in a configuration file enables this rule.

Angle bracket components use the `@argument` style and that's why users are more likely to start making this mistake.

For case like:

```hbs
<option @value="1" />
```

we have untrackable error like

```txt
Uncaught (in promise) TypeError: func is not a function
    at Compilers.compile
    at compile
    at LazyCompiler.add
    at CompilableBlock.compile
    at Object.evaluate
    at AppendOpcodes.evaluate
    at LowLevelVM.evaluateSyscall
    at LowLevelVM.evaluateInner
    at LowLevelVM.evaluateOuter
    at VM.next
```

This is untraceable for end-users.
This linting rule determines if it is a component or not and emits an error if argument is assigned to a lower-case element without the same block name and without dots in notation.

## Examples

This rule **forbids** the following:

```hbs
<picture @name="Cat" >
```

```hbs
<img @src="1" >
```

This rule **allows** the following:

```hbs
<Picture @name="Cat" />
```

```hbs
<Img @src="1" />
```

```hbs
{{#let (component "bar" as |foo|}}
  <foo @name="1" />
{{/let}}
```

```hbs
<foo.some.name @name="1"/>
<@foo @name="2" />
<EMAIL_ADDRESS>@name="2" />
```

```hbs
<MyComponent>
  <:slot @name="Header"></:slot>
</MyComponent>
```

## Related Rules

* [no-potential-path-strings](no-potential-path-strings.md)

## References

* [Component Arguments and HTML Attributes](https://guides.emberjs.com/release/components/component-arguments-and-html-attributes/)

repository: ember-template-lint/ember-template-lint

repo_name: ember-template-lint/ember-template-lint


text:
# Exec

This package provides an interface for `os/exec`. It makes it easier to mock
and replace in tests, especially with the [FakeExec](testing/fake_exec.go)
struct.

repository: kubernetes/kubernetes

gha_language: Go

repo_name: kubernetes/kubernetes


text:
# Node Web Bluetooth
Node.js implementation of the [Web Bluetooth Specification](https://webbluetoothcg.github.io/web-bluetooth/)

[![Build Status](https://github.com/thegecko/webbluetooth/workflows/prebuild/badge.svg)](https://github.com/thegecko/webbluetooth/actions)
[![npm](https://img.shields.io/npm/dm/webbluetooth.svg)](https://www.npmjs.com/package/webbluetooth)
[![Licence MIT](https://img.shields.io/badge/licence-MIT-blue.svg)](http://opensource.org/licenses/MIT)

## Prerequisites

[Node.js > v10.20.0](https://nodejs.org), which includes `npm`.

## Installation

```bash
$ npm install webbluetooth
```

## Getting Started

See the [examples](https://github.com/thegecko/webbluetooth/tree/master/examples/) or view the API documentation at:

https://thegecko.github.io/webbluetooth/

## Usage

The module exports a default `navigator.bluetooth` instance, the `Bluetooth` class to allow you to instantiate your own bluetooth instances and the Bluetooth helper methods:

- [bluetooth](globals.html#bluetooth)
- [Bluetooth()](classes/bluetooth.html)
- [BluetoothUUID.getService()](globals.html)
- [BluetoothUUID.getCharacteristic()](globals.html)
- [BluetoothUUID.getDescriptor()](globals.html)
- [BluetoothUUID.canonicalUUID()](globals.html)

### Using the default bluetooth instance

To use existing Web Bluetooth scripts, you can simply use the default `bluetooth` instance in place of the `navigator.bluetooth` object:

```JavaScript
const bluetooth = require('webbluetooth').bluetooth;

const device = await bluetooth.requestDevice({
    filters:[{ services:[ 'heart_rate' ] }]
});

const server = await device.gatt.connect();
...
```

The first device matching the filters will be returned.

### Creating your own bluetooth instances

You may want to create your own instance of the `Bluetooth` class. For example, to inject a device chooser function or control the referring device:

```JavaScript
const Bluetooth = require('webbluetooth').Bluetooth;

const deviceFound = (device, selectFn) => {
    // If device can be automatically selected, do so by returning true
    if (device.name === 'myName') return true;

    // Otherwise store the selectFn somewhere and execute it later to select this device
};

const bluetooth = new Bluetooth({ deviceFound });

const device = await bluetooth.requestDevice({
    filters:[{ services:[ 'heart_rate' ] }]
});

const server = await device.gatt.connect();
...
```

## Specification

The Web Bluetooth specification can be found here:

https://webbluetoothcg.github.io/web-bluetooth/

## Implementation Status

### bluetooth

- [ ] getAvailability() - unsupported in adapter
- [x] referringDevice
- [x] requestDevice()
- [x] getDevices()
- [x] RequestDeviceOptions.filter.name
- [x] RequestDeviceOptions.filter.namePrefix
- [x] RequestDeviceOptions.filter.services
- [x] RequestDeviceOptions.filter.manufacturerData
- [x] RequestDeviceOptions.filter.serviceData
- [x] RequestDeviceOptions.acceptAllDevices
- [x] RequestDeviceOptions.optionalServices
- [ ] RequestDeviceOptions.exclusionFilters
- [ ] RequestDeviceOptions.optionalManufacturerData - used in advertisements, unsupported in adapter

### BluetoothDevice

- [x] id
- [x] name
- [x] gatt
- [x] forget()
- [ ] watchAdvertisements() - unsupported in adapter
- [ ] watchingAdvertisements - unsupported in adapter

### BluetoothRemoteGATTServer

- [x] device
- [x] connected
- [x] connect()
- [x] disconnect()
- [x] getPrimaryService()
- [x] getPrimaryServices()

### BluetoothRemoteGATTService

- [x] uuid
- [x] device
- [x] isPrimary
- [x] getCharacteristic()
- [x] getCharacteristics()
- [ ] getIncludedService() - unsupported in adapter
- [ ] getIncludedServices() - unsupported in adapter

### BluetoothRemoteGATTCharacteristic

- [x] uuid
- [x] service
- [x] value
- [ ] properties.broadcast - unsupported in adapter
- [x] properties.read
- [x] properties.writeWithoutResponse
- [x] properties.write
- [x] properties.notify
- [x] properties.indicate
- [ ] properties.authenticatedSignedWrites - unsupported in adapter
- [ ] properties.reliableWrite - unsupported in adapter
- [ ] properties.writableAuxiliaries - unsupported in adapter
- [x] getDescriptor()
- [x] getDescriptors()
- [x] readValue()
- [x] writeValue()
- [x] writeValueWithResponse()
- [x] writeValueWithoutResponse()
- [x] startNotifications()
- [x] stopNotifications()

### BluetoothRemoteGATTDescriptor

- [x] uuid
- [x] characteristic
- [x] value
- [x] readValue()
- [x] writeValue()

### BluetoothUUID

- [x] getService()
- [x] getCharacteristic()
- [x] getDescriptor()
- [x] canonicalUUID()

### Events

#### Bluetooth

- [ ] availabilitychanged - unsupported in adapter

#### Bluetooth Device

- [x] gattserverdisconnected
- [ ] advertisementreceived - unsupported in adapter

#### Bluetooth Service

- [x] serviceadded
- [ ] servicechanged - unsupported in adapter
- [ ] serviceremoved - unsupported in adapter

#### Bluetooth Characteristic

- [x] characteristicvaluechanged

### Other

- [x] Device selector hook
- [x] Examples
- [x] API Documentation

## Development

### Cloning

This repository uses a submodule to reference the SimpleBLE library. Clone it as follows:

```bash
git clone https://github.com/thegecko/webbluetooth
cd webbluetooth
git submodule update --init
```

### Building

To build the SimpleBLE module, bindings and TypeScriptsource, run:

``` bash
yarn build:all
```

### Testing

The tests are set up to use a BBC micro:bit in range with the following services available:

- Device Info Service (0000180a-0000-1000-8000-00805f9b34fb)
- LED Service (e95dd91d-251d-470a-a062-fa1922dfa9a8)
- Button Service (e95d9882-251d-470a-a062-fa1922dfa9a8)

Firmware for this hardware including the services can be found here: https://microbit.org/get-started/user-guide/firmware/

To run the tests:

```bash
yarn test
```

repository: thegecko/webbluetooth

repo_name: thegecko/webbluetooth


text:
---
title: Building a component based app with React
excerpt: The most recent answer to build and scale complex web applications are components, divide an interface in smaller and autonomous blocks to conquer maintainability and scalability. I'm going to explore how developing a component-based app with React looks like and the current state of its ecosystem.
---

_This writing belongs to a serie of articles about using components with [Vue][vue-article], React, [Polymer][polymer-article] and [Angular 2][angular-article]._

In this case I will go through my thoughts and feelings on developing a web application using [React][react], probably the most popular library to render views these days, created by Facebook developers.

## Introduction to React

According to its authors, the mear existence of this framework is to compose large web applications through components and not directives. Those components will only be updated if the data bound to them does.

To achieve this React provides a set of methods to express HTML elements with object notation, an abstraction pattern usually known as _virtual DOM_.

Instead of creating and appending elements as usual, you represent them with an object passing tag, properties and children to the `createElement` function.

```js
let Link = React.createElement(
  'a',
  {
    href: '//github.com/jeremenichelli',
    className: 'github-link'
  },
  'GitHub'
);
```

{% codeExampleLink '//jsfiddle.net/jeremenichelli/kqLmfcq4' %}

In this example we are creating an anchor, passing the `href` and `class` properties and a text node as its only children.

It's necessary to express element's properties as their JavaScript equivalent, that's why `className` is used instead of `class`.

### JSX

Not mandatory, but an optional way to describe render trees is **JSX** which basically let's you describe React elements in a syntax similar to HTML.

```js
const GitHubLink = (
  <a className="github-link" href="//github.com/jeremenichelli">
    GitHub
  </a>
);
```

Seeing tags inside your code might feel weird at first, however it becomes a better option when writing more complex elements with a bigger number of children that can be harder to read using React's method.

Of course this will need to be _transpiled_ to actually work, but more on that later.

## Writing components

As React promises, the best reason for using it is to improve the architecture of your application diving the views into reusable components.

One of the many ways to achieve this is extending the component class.

```js
import React, { Component } from 'react';
import { render } from 'react-dom';

class GitHubLink extends Component {
  render() {
    return (
      <a href="//github.com/jeremenichelli" className="github-link">
        {this.props.user} on github
      </a>
    );
  }
}

render(
  <GitHubLink user="jeremenichelli" />,
  document.querySelector('#example')
);
```

These components become custom tags you can put inside other components or pass it to the render function. Component tags need to be **capitalized** so JSX can differenciate them from standard HTML ones.

The problem with this component here is that the url is hardcoded, and an anchor always pointing to the same page won't be _that_ reusable.

### Props

To customize our components, data values can be passed to them as _props_.

```js
import React, { Component } from 'react';
import { render } from 'react-dom';

const baseUrl = '//github.com/';

class GitHubLink extends Component {
  constructor(props) {
    super(props);
  }
  render() {
    return (
      <a href={baseUrl + this.props.user} className="github-link">
        {this.props.user} on github
      </a>
    );
  }
}

render(
  <GitHubLink user="jeremenichelli" />,
  document.querySelector('#example')
);
```

When declaring components with this pattern, _props_ need to be passed to the **super** class constructor so they are applied to the component itself.

As you see in the **href** value, JavaScript expressions can be used inside JSX when wrapped with curly braces to apply more dynamic and readable approaches.

```js
import React, { Component } from 'react';
import { render } from 'react-dom';

const baseUrl = '//github.com/';

class GitHubLink extends Component {
  constructor(props) {
    super(props);
  }
  render() {
    return (
      <a href={baseUrl + this.props.user} className="github-link">
        {this.props.user} on github
      </a>
    );
  }
}

class GitHubUsers extends Component {
  constructor(props) {
    super(props);
  }
  render() {
    return (
      <div>
        <GitHubLink user="jeremenichelli" />
        <GitHubLink user="iamdustan" />
      </div>
    );
  }
}

render(<GitHubUsers />, document.querySelector('#example'));
```

{% codeExampleLink '//jsfiddle.net/jeremenichelli/oLL9j1bj/3' %}

The render function in React components always has to return a single root element, that's why the two GitHub links are placed inside a **div** tag.

Remember you can use JavaScript inside `render`, which is pretty neat when the number of children is unknown or too big.

```js
import React, { Component } from 'react';

const users = ['jeremenichelli', 'iamdustan'];

class GitHubUsers extends Component {
  constructor(props) {
    super(props);
  }
  render() {
    return (
      <div hidden={!users.length}>
        {users.map((user) => (
          <GitHubLink user={user} />
        ))}
      </div>
    );
  }
}
```

{% codeExampleLink '//jsfiddle.net/jeremenichelli/oLL9j1bj/4/' %}

This is a better pattern since now the logic inside `render` doesn't need to be updated when the data changes, improving the maintainability of the code.

#### PropTypes

Validation can be added to props, for example specifying type.

```js
GitHubLink.propTypes = {
  user: PropTypes.string.isRequired
};
```

After passing the type we can go further and use `isRequired` so the presence of it becomes mandatory for rendering the component.

_propTypes have been moved to [a standalone package](//reactjs.org/docs/typechecking-with-proptypes.html)._

### State

When data values can change internally because a network request or a user interaction happened, we placed them on the component's _state_.

```js
import React, { Component } from 'react';

class AccordionElement extends Component {
  constructor(props) {
    super(props);

    this.state = {
      expanded: false
    };
  }
  render() {
    return (
      <div className={this.state.expanded ? 'expanded' : ''}>
        <button>{this.props.heading}</button>
        <p>{this.props.content}</p>
      </div>
    );
  }
}
```

Here in this accordion element, the _expanded_ value will define whether the content will be visible or not, so it makes sense to define it as a _state_.

To reveal the content we need to toggle the _expanded_ value.

To do it we use `setState` and React will update the components view.

```js
import React, { Component } from 'react';

class AccordionElement extends Component {
  constructor(props) {
    super(props);

    this.state = {
      expanded: false
    };
  }
  toggleState() {
    this.setState({ expanded: !this.state.expanded });
  }
  render() {
    return (
      <div className={this.state.expanded ? 'expanded' : ''}>
        <button onClick={this.toggleState.bind(this)}>
          {this.props.heading}
        </button>
        <p>{this.props.content}</p>
      </div>
    );
  }
}
```

{% codeExampleLink '//jsfiddle.net/jeremenichelli/oLL9j1bj/5' %}

When the `toggleState` function gets called the context will be the rendered node, with `bind` we change it back to the component.

### Model binding

As the library doesn't come with directives out of the box, when you need to track properties like the value of an input you will have to do it yourself.

It's not hard since React encapsulation itself comes handy for this.

```js
import React, { Component } from 'react';

export default class SearchBox extends Component {
  constructor(props) {
    super(props);

    this.state = {
      searchValue: ''
    };

    // bind events
    this.handleChange = this.handleChange.bind(this);
  }
  handleChange(e) {
    this.setState({ searchValue: e.target.value });
  }
  render() {
    return (
      <form action="?">
        <input
          type="text"
          value={this.props.searchValue}
          onChange={this.handleChange}
        />
        <button type="submit">Search</button>
      </form>
    );
  }
}
```

This is a pretty common pattern that allows you to access to that _state_ later in case it affects some other rendered section of the component.

### Styles

If you're using React, the main reason should be that you find the separation of concerns and encapsulation the best way to structure your application, so your strategy around styles should match this philosophy.

**CSS modules** alter original selectors so they are unique, and as a consequence, encapsulates the styles for a set of elements.

```js
import React, { Component } from 'react';

import styles from '../styles/icon.css';

class Icon extends Component {
  render() {
    return <i className={styles.icon}></i>;
  }
}
```

When you import a style file like this, selectors are changed to keys, combinations of letters and numbers. Inside your script an object is returned containing exactly those unique references you can use in your components as classes.

Of course this happens at compilation time so you will need external tools like [webpack loaders][css-modules-webpack] to manage your styles this way.

### Routing

The most popular alternative to turn your React project in a single page application is the [official react router][react-router]. As you might have guessed, you need to define the shell of your app and the views as components.

```js
import React, { Component } from 'react';

class App extends Component {
  render() {
    return (
      <div className="app">
        <h1>React single page application</h1>
        {this.props.children}
      </div>
    );
  }
}

class Home extends Component {
  render() {
    return (
      <div className="home">
        <h2>Home</h2>
        // view content ...
      </div>
    );
  }
}

class About extends Component {
  render() {
    return (
      <div className="about">
        <h2>About</h2>
        // view content ...
      </div>
    );
  }
}
```

Next, you pass these views as _props_ to special route components that will mount the app and manage the transitions for you.

```js
import { render } from 'react-dom';
import { Router, Route, IndexRoute } from 'react-router';

render(
  <Router>
    <Route path="/" component={App}>
      <IndexRoute component={Home} />
      <Route path="/about" component={About}>
        <Route path="/about/:author" component={Author}></Route>
      </Route>
    </Route>
  </Router>,
  document.getElementById('app')
);
```

Basically you're configuring the routes by placing tags defining the structure of your project, meaning you can go deeper placing routes and defining parameters.

```js
import React, { Component } from 'react';
import { Link } from 'react-router';

class Home extends Component {
  render() {
    return (
      <div className="home">
        <h2>Home</h2>
        <Link to="about/jeremenichelli">About me</Link>
        // view content ...
      </div>
    );
  }
}
```

To render anchors pointing to a defined route, a **Link** component is available.

## Ecosystem

Even when it has a great and growing community, its ecosystem is its weakest point.

Try to learn a new framework always brings a learning curve that, in my opinion, is too steep in React. There are a lot of reasons for that.

The first one is the **documentation**. I have to admit is really complete but unorganized, which is a big deal for begginers, probably a consequence of a fast evolution pace the repository experimented recently.

> The official docs grew organically and need gardening.
> <cite>Dan Abramov</cite>

The second one is **JSX** itself. Using it really improves the developing experience, but it brings its own tricks and limitations to the yard.

I would suggest trying React without it first or you will find yourself learning two things at the same time, not knowing _what's wrong and where_ when your script renders nothing.

The last one is **tooling**. If you're building your application with React, you will need transpiling and a build process to handle the whole thing since you're choosing this path to structure your project separating it in smaller parts.

There are a lot of boilerplates, which I think is a symptom of what's going on with the library nowadays. Apparently developers are having a hard time around decisions when they start a new project which includes React.

## Architecture

This heading probably won't be present in all the articles from this serie and the reason is React actually shaped the structure of my application.

While trying to avoid repeated code and follow best practices, the library itself in combination with CSS modules _forced_ me in own way or another to encapsulate both logic and styles.

### Components as modules

Once you've resolved the tooling part, enclosing each component as a module is the best way to organize an application that might scale in time.

The **SearchBox** component example shown previously can be easily imported to compose more complex components or views.

```js
import React, { Component } from 'react';

// components
import Card from '../components/card.js';
import SearchBox from '../components/search-box.js';

export default class SearchView extends Component {
  constructor(props) {
    super(props);
  }
  render() {
    return (
      <Card>
        <SearchBox />
      </Card>
    );
  }
}
```

Following this design rules, the project grows naturally without overthinking around where you should put something or where not, and that's a big win from this library.

## Wrap-up

React has something that makes you like it, it does **one** thing. Short set of methods and patterns to learn and you're ready to go, but it needs to improve documentation and tooling to help onboard new adopters without strong concepts around architecture and components.

It definitely forces you to change how you develop and scale an application, but after you passed the initial learning curve, letting React rule your project's architecture is a relief.

Most of these thoughts came while building a [simple web app][react-app] using tools and approaches mentioned in this article you can explore on GitHub.

[react]: //facebook.github.io/react
[props]: //facebook.github.io/react/docs/reusable-components.html#single-child
[css-modules]: //andrewhfarmer.com/what-are-css-modules/
[css-modules-webpack]: //css-modules.github.io/webpack-demo/
[react-router]: //github.com/reactjs/react-router
[react-app]: //github.com/jeremenichelli/movies/tree/master/results/react
[vue-article]: /2016/06/building-component-based-app-vue/
[react-article]: /2016/07/building-a-component-based-app-react/
[polymer-article]: /2016/08/building-a-component-based-app-polymer/
[angular-article]: /2016/08/building-component-based-app-angular-2/

repository: jeremenichelli/personal-site

repo_name: jeremenichelli/personal-site


text:
# honeyDoIonic

## What is the project about?

This is the Ionic frontend for a full MEAN stack todo app.

## What technologies does the project use?

NPM, HTML5, CSS3, JavaScript, Ionic, and AngularJS.

## Download and install:

*If you don't have NPM yet, from terminal:*

`curl https://npmjs.org/install.sh | sh`

In your browser, navigate to [the repo] (https://github.com/ldmcdaniel/honeyDoIonic).

In the top-right corner of the page, click Fork.

In your designated code directory, type:

```sh
git clone https://github.com/Your-Username/honeyDoIonic
cd honeyDoIonic
npm install
ionic serve
```

Open with your favorite text editor and you should be ready to start coding.

repository: ldmcdaniel/honeyDoIonic

repo_name: ldmcdaniel/honeyDoIonic


text:
# Typo 📝

_NOTE: This template is still missing some small details before hitting v0.1.0.
You can track the progress
[here](https://github.com/daniel-vera-g/typo/projects/1) and subscribe to the
releases to get notified._

> You want to use the simplicity of markdown but not give up the power of
> latex? Well, with this template you can use both and stay flexible 🚀

[![Build](https://github.com/daniel-vera-g/typo/actions/workflows/build.yml/badge.svg)](https://github.com/daniel-vera-g/typo/actions/workflows/build.yml)
[![Grammar and spelling
check](https://github.com/daniel-vera-g/typo/actions/workflows/language.yml/badge.svg)](https://github.com/daniel-vera-g/typo/actions/workflows/language.yml)
[![Super-Linter](https://github.com/daniel-vera-g/typo/actions/workflows/lint.yml/badge.svg)](https://github.com/daniel-vera-g/typo/actions/workflows/lint.yml)

**Features:**

- [x] Continuous integration:
  - _Build whole document using latex_
  - _Check Grammar and spelling_
  - _Lint markdown, latex, .... files_
- [x] Continuous delivery: _Save generated PDF as artifact_
- [x] Use _markdown_ as lightweight markup language
- [x] Use _latex_ for the document preparation, Math formulas, ...
- [x] Use _citations_ easily

---

## Requirements

> Please make sure to have at least the required tools set up before starting 😄

1. **Required**:
   - [Pandoc](https://pandoc.org/) to convert markdown to PDF using latex
   - [Latex](https://www.latex-project.org/)
   - [Bibtex](http://www.bibtex.org/)
   - [Make](https://www.gnu.org/software/make/manual/make.html)
2. _Optional_:
   > The following tools are not really needed to build the document.
   > Nevertheless, they help with linting, fixing, ...
   - [The Pandoc Eisvogel template](https://github.com/Wandmalfarbe/pandoc-latex-template/):
     Awesome latex/markdown template
   - [TeXtidote](https://github.com/sylvainhalle/textidote): Latex/Markdown cli
     language/spell checker
   - [Prettier](https://prettier.io/): Format and prettify your documents
   - [Markdownlint](https://github.com/igorshubovych/markdownlint-cli):
     Check/Fix your markdown files

## Get started

1. Click the green `Use this template` button on the top right corner
2. Now you're ready to go 🚀: Just write your content using markdown and include
   you references or use latex as described below.

## Guides

> Fun fact: The documentation of this template already uses its features 🔄. You
> can use it as example 😄

- You can use most of the features mentioned below with simple `make` commands.
  Check out the next sections for details.

1. Organize your documents in folders 📙:
   [How to use folders](./docs/folders.md)
2. Use citations to use references 📖:
   [How to use citations](./docs/citations.md)
3. Use latex in your markdown writing 👨🏫 : [How to use latex](./docs/latex.md)
4. Customize the generated PDF document 💡:
   [How to customize your document](./docs/customization.md)
5. Spell and grammar check your files 💬 :
   [How to check language](./docs/language.md)
6. Run automatically CI/CD pipelines when you push to GitHub 🏗:
   [How the CI/CD works](./docs/ci-cd.md)
7. And there is even more awesome tooling you can use to enhance your workflow
   💅: [Even more tooling](./docs/tooling.md).

## Commands 🔧

> `make` is used for build automation. Refer to the [Makefile](./Makefile).

1. Generate PDF: `make`
2. Generate docx: `make docx`.

The next recipes make use of the _optional_ dependencies:

<!-- markdownlint-disable MD029 -->

3. Generate PDF using the eisvogel template: `make eisvogel`
4. Lint markdown files: `make lint`
5. Automatically try to fix markdown files: `make fix`
6. Try to format markdown files automatically: `make format`
7. Check language and grammar: `make check-lang`
8. Generate an HTML language/grammar report you can see in the browser:
   `make lang-report`. The report output will be in an `lang-report.html` file.
9. Sync word list(See _"How to check language"_ section for details): `make sync-wl`
<!-- markdownlint-enable MD029 -->

### Using VS Code

> If you use VS Code, you can run the commands above using VS Code `tasks`

Run the `Run Task` command or simply hit `Ctrl/Cmd + F9`:

![VS Code example](./img/2021-05-01-12-24-13.png)

## Development/Contributing 👨💻

1. Please request changes in the
   [issue tracker](https://github.com/daniel-vera-g/typo/issues) after that, you
   can open a PR :-)
2. See the section about CI/CD. The Pipelines should work.

## TODO 🏁

> See: [Issues](https://github.com/daniel-vera-g/typo/issues/)

## Acknowledgment

- [TeXtidote](https://github.com/sylvainhalle/textidote): Latex/Markdown cli
  language/spell checker
- [The Pandoc Eisvogel template](https://github.com/Wandmalfarbe/pandoc-latex-template/):
  Awesome latex/markdown template

repository: daniel-vera-g/typo

repo_name: daniel-vera-g/typo


text:
[com.coinzgame.theoxo.coinz](../index.md) / [BankCoinsFromWalletThenInboxTest](index.md) / [bankSingleCoinTest](.)

# bankSingleCoinTest

`fun bankSingleCoinTest(): Unit`

Combines the tests for banking coins from the wallet and the inbox to make sure
that doing the latter does not overwrite anything from doing the former.
This was set up in response to a bug where depositing coins from the inbox would reset the
counter of coins deposited from the wallet to 0.
This requires that a user with email<EMAIL_ADDRESS>and
password "testtest111" is registered in the authentication service.
It also requires a fresh install of the app, so before running the test make sure
the app is not already installed on the device. Running this test inside of a test suite
will therefore not work.

repository: theoxo/CoinzAndroidGame

repo_name: theoxo/CoinzAndroidGame


text:
Orchestra Platform Asset Component
==============

`Orchestra\Asset` Component is a port of Laravel 3 Asset for Orchestra Platform.

[![Latest Stable Version](https://poser.pugx.org/orchestra/asset/v/stable.png)](https://packagist.org/packages/orchestra/asset)
[![Total Downloads](https://poser.pugx.org/orchestra/asset/downloads.png)](https://packagist.org/packages/orchestra/asset)
[![Build Status](https://travis-ci.org/orchestral/asset.svg?branch=master)](https://travis-ci.org/orchestral/asset)
[![Coverage Status](https://coveralls.io/repos/orchestral/asset/badge.png?branch=master)](https://coveralls.io/r/orchestral/asset?branch=master)
[![Scrutinizer Quality Score](https://scrutinizer-ci.com/g/orchestral/asset/badges/quality-score.png?s=3f3515804e4acb3e93c56f62559ac0b96ee74f24)](https://scrutinizer-ci.com/g/orchestral/asset/)

## Quick Installation

To install through composer, simply put the following in your `composer.json` file:

```json
{
	"require": {
		"orchestra/asset": "2.2.*"
	}
}
```

Add `Orchestra\Asset\AssetServiceProvider` service provider in `app/config/app.php`.

```php
'providers' => array(

	// ...

	'Orchestra\Asset\AssetServiceProvider',
),
```

### Aliases

You might want to add `Orchestra\Support\Facades\Asset` to class aliases in `app/config/app.php`:

```php
'aliases' => array(

	// ...

	'Orchestra\Asset' => 'Orchestra\Support\Facades\Asset',
),
```

## Resources

* [Documentation](http://orchestraplatform.com/docs/latest/components/asset)
* [Change Log](http://orchestraplatform.com/docs/latest/components/asset/changes#v2-2)


text:
# Team JuJaJeLo

## Management Plan

###Team Member Roles

* Jason
    * Primary: Frontend, mainly frontend implementation with GUI Components and interaction with user
    * Secondary: Help with controller interface with backend

* Jerry
    * Primary: ControllerAPI implementation
    * Secondary: Help where needed interfacing with frontend/backend and maintaining data interface

* Justin
    * Primary: Backend/ AI interaction with less intelligent to smarter AI algorithms
    * Secondary: Data management, interfacing with the controller

* Loten
    * Primary: Backend: Helping with AI, as well as managing data in the backend to process
    * Secondary: Data management, interfacing with the controller

##Rough Timeline for Sprints

* ooga.Main Goals:
    * Implement at least 3 games:
        * Tic-Tac-Toe
        * Checkers
        * Connect Four
        * Othello
    * Allow for either 2 players or playing a computer
    * Implement some optional features: preferences, load/save game, player profile, and difficulty with AI

* Sprint 1

    * Get a working test implementation with basic AI, such as a basic Tic-Tac-Toe working with basic/ advancing AI algorithm
    * Set up a gameboard for chess, connect four, othello, etc.
    * Set up core classes with abstractions/interfaces/clean inheritance hierarchy
    * Use .CSS and .properties files to start with

* Sprint 2

    * Get a more elaborate GUI elements
    * Implementing the rest of the games in functionality: checkers, connect four, othello
    * Working AI to play against
    * At least a bare bones working version of everything
    * Start adding optionals

* Sprint 3/Complete
    * Refining optionals
    * Improving AI if possible, multiple versions in difficulty
    * Add additional games if time permits


text:
---
title: "Contributions"
subheadline: "Give back to the community"
teaser: "Report/fix bugs, provide support, improve projects."
type: app
images:
  icon: projects/contributions/github.png
  icon_small: projects/contributions/github-icon.png
links:
  sources: https://github.com/TWiStErRob/repros
---

{% include toc.md %}

## Inception
I now have the habit of reporting issues I find in the tools I use.
Actually don't remember how it came about...
I think it might come from my first job where I was doing manual testing and had to report everything I found.

### Motivation
I want to make the world better by improving the tools we use.
If there's something wrong, I try to report it so that the owner can make a decision what to do.

## Implementation
This means I'm reporting bugs, missing features, and I'm also trying to fix them where applicable.

Over the years I realized that juggling ZIP files around is not the most effective way to share code,
so I created a [repo of repros](https://github.com/TWiStErRob/repros) where I collect all the projects for the issues I filed.

This forces me to make a minimal independent reproducer, so that maintainers can more easily asses the problem.
From my experience on [Glide]({{ site.baseurl }}/work/2014-glide/ ) I found that
oftentimes it's enough to just be able to browse the repro files to find the problem, this is why I think a GitHub repo works.

## Investigations
Many times I can also contribute by spending a deep debugging session sleuthing for a root cause and reporting a bug with full details.

Note: examples in this section are really heavily detailed and deeply technical and messy in some cases.
They might be slightly out of date as well, since they record the state of the environment at the time of the investigation.
They're still interesting reads if you're curious about how to approach complex problems.

### [Bad quality when saving Bitmaps as JPEG on Android](https://stackoverflow.com/a/36560663/253468)
This is one of the most complex ones, it involves all levels of Android, from Java to native code and back.
It all started when I noticed that all my pictures of my desk had some banding on them, and they looked like the GIFs did in the 90s.

<img src="https://i.stack.imgur.com/vIuH4.jpg" width="400" />

After asking a StackOverflow question where Android community support rejected that's a problem, and Google straight up closed the issue as "Obsolete",
I dug deep into where the Bitmap to JPEG compression happens and found that some constants were not set correctly, they had rounding errors.
On the way I learned a lot about how JPEG compression works.
I even got 2 lines of help from Irfan Skiljan, the author of [IrfanView](https://www.irfanview.com/), which nudged me in the right direction of discovery.

Luckily I had a friend at Google who was able to route the issue, now complete with an exact route cause and fix proposal, to the right team.
They landed a fix at https://codereview.chromium.org/1886183002/, which means Android and Chrome should have better quality pictures from then on.

### [Kotlin vs Android Gradle Plugin vs Gradle JVM Targets](https://stackoverflow.com/a/75158443/253468)
This is a short investigation of a problem which I think affects or will affect many of the Android community.
After finding the root cause, we reported the problem to JetBrains, and they provided a workaround.
This workaround does not fix the issue, but avoids it, by using newer approaches in Gradle tooling.

### [Obfuscating Android code with ProGuard while keeping code debuggable and readable](https://stackoverflow.com/q/29871644/253468)
I wanted to debug an obfuscated Android app, but I couldn't, because everything was called `a`, `b` or `c`, so I was totally lost.
I found a way to apply obfuscation, but define how the names are changed, but it was not easy.
This helped me fix my problem, and probably not in a usable form right now. Might come in handy at some point.

### [Truth vs Paparazzi vs Guava dependencies](https://github.com/cashapp/paparazzi/issues/906)
This was a short investigation of a Gradle dependency resolution issue.
It seems it has started to lead to a Google considering to improve bring Guava `-android` artifact closer to `-jre`.

### [Mockito Gradle warning cleanup](https://github.com/mockito/mockito/pull/2904)
This is a small contribution following a hours of investigation with full details of my process on how I approach Gradle build problems.

### [Kotlin Power Assert tech debt](https://github.com/bnorm/kotlin-power-assert/pull/87)
A Kotlin Power Assert contributor become [blocked](https://github.com/bnorm/kotlin-power-assert/pull/86#issuecomment-1494350875)
while trying to bump a small dependency version, and got entangled in a major Gradle 8 upgrade.
I helped upgrade Gradle 8, so they can continue the contribution.

There was a little surprise undocumented breaking change by the Gradle Plugin Portal plugin, but luckily for the better.

### [Kotlin scripting failures](https://github.com/Kotlin/kotlin-script-examples/issues/21#issuecomment-1302593643)
On one of my watched repositories there came a request for help, and I dug deep into why their code was failing.
I showed my working and left some hints, hopefully they learned from it, I definitely did.

> WOW... thanks so much... your sleuthing is beyond my Kotlin skills...

### [Glide progress bar](https://github.com/bumptech/glide/issues/232#issuecomment-172625621)
One day at Glide a support request came in, and it was an interesting problem.
I hacked together a proof of concept that I shared in the issue. Hopefully it helped others.

### [Dialog crash on Android Emulator](https://github.com/TWiStErRob/net.twisterrob.inventory/issues/157)
This was a failure that was bugging me a lot, and I wanted to find out what's going on.
Had to dig deep into native code again, and reason I found surprised me.
Reported to Google, and they picked it up years later and by that time it seems it was already fixed.

gha_language: SCSS


text:
---
id: 550
title: Windows Server Cluster Management Pack for Operations Manager 2007
date: 2009-02-13T14:04:00+10:00
author<EMAIL_ADDRESS>
guid: /blogs/scom/archive/2009/02/13/windows-server-cluster-management-pack-for-operations-manager-2007.aspx
sc_member_order:
  - "0"
  - "0"
  - "0"
  - "0"
  - "0"
  - "0"
post_views_count:
  - "1495"
  - "1495"
  - "1495"
  - "1495"
  - "1495"
categories:
  - SystemCenter
  - Uncategorized
tags:
  - Management Pack
  - Operations Manager 2007
  - opsmgr
  - scom
---
#### Overview

  The Windows Server Failover Cluster Management Pack provides both proactive and reactive monitoring of your Windows Server 2003 and Windows Server 2008 cluster deployments. It monitors Cluster services components—such as nodes, networks, resources, and resource groups—to report issues that can cause downtime or poor performance.

    Feature Summary
Some of the conditions monitored by this management pack are as follows:

          Configuration or hardware issues that interfere with starting the Cluster service

          Connectivity problems that affect communication between cluster nodes or between a node and a domain controller

          Active Directory Domain Services (AD DS) settings that affect the cluster; for example, permissions needed by the computer account that is used by the cluster

          Configuration issues with the network infrastructure needed by the cluster; for example, issues with Domain Name System (DNS)

          Issues with the availability of a cluster resource, such as a clustered file share

          Issues with the cluster storage

      Release History:

        3/6/2008 – 6.0.6277.0 – Original English release

        4/2/2008 – 6.0.6277.1 – Updated version, see MP guide for details

        2/12/2009 – 6.0.6505.0 – Introduced support for Windows Server 2008 clusters and addressed some issues from the previous release.

      Download here: http://www.microsoft.com/downloads/details.aspx?FamilyId=AC7F42F5-33E9-453D-A923-171C8E1E8E55&displaylang=en&displaylang=en

      Grtz,

      Alexandre Verkinderen


text:
{
    "title": "No Treason - The Constitution of No Authority",
    "authors": ["Lysander Spooner"],
    "publishdate": "1869-01-19",
    "tags": ["Law"]
}

The Constitution has no inherent authority or obligation. It has no
authority or obligation at all, unless as a contract between man and
man. And it does not so much as even purport to be a contract between
persons now existing. It purports, at most, to be only a contract
between persons living eighty years ago . 1 And it can be supposed to
have been a contract then only between persons who had already come to
years of discretion, so as to be competent to make reasonable and
obligatory contracts. Furthermore, we know, historically, that only a
small portion even of the people then exist¬ ing were consulted on the
subject, or asked, or permitted to express either their consent or
ndissent in any formal manner. Those persons, if any, who did give
their consent formally, are all dead now. Most of them have been dead
forty, fifty, sixty, or seventy years. And the Constitution, so far as
it t oas their contract, died with them.  They had no natural power or
right to make it obligatory upon their children. It is not only
plainly impossible, in the nature of things, that they could bind
their posterity, but they did not even attempt to bind them. That is
to say, the instrument does not purport to be an agreement between any
body but “the people” then existing; nor does it, either expressly or
impliedly, assert any right, power, or disposition, on their part, to
bind anybody but themselves. Let us see. Its language is:

We, the people of the United States (that is, the people then existing
in the United States), in order to form a more perfect union, insure
domestic tranquility, provide for the common defense, promote the
general welfare, and secure the blessings of liberty to ourselves ana
our posterity, do ordain and establish this Constitu¬ tion for the
United States of America.

It is plain, in the first place, that this language, as an agreement,
purports to be only what it at most really was, viz., a contract
between the people then existing; and, of necessity, binding, as a
contract, only upon those then existing. In the second place, the
language neither expresses nor implies that they had any intention or
desire, nor that they imagined they had any right or power, to bind
their “posterity” to five under it. It does not say that their
“posterity” will, shall, or must live under it. It only says, in
effect, that their hopes and motives in adopting it were that it might
prove useful to their posterity, as well as to themselves, by
promoting their imion, safety, tranquility, liberty, etc.

Suppose an agreement were entered into, in this form:

We, the people of Boston, agree to maintain a fort on Governor’s
Island, to protect ourselves and our posterity against invasion.

This agreement, as an agreement, would clearly bind nobody but the
people then existing. Secondly, it would assert no right, power, or
disposition, on their part, to compel^their “posterity” to maintain
such a fort. It would only indicate that the supposed wel¬ fare of
their posterity was one of the motives that induced the original
parties to enter into the agreement.

When a man says he is building a house for himself and his posterity,
he does not mean to be understood as saying that he has any thought of
binding them, nor is it to be inferred that he is so foolish as to
imagine that he has any right or power to bind them, to live in it. So
far as they are concerned, he only means to be understood as saying
that his hopes and motives, in building it, are that they, or at least
some of them, may find it for their happiness to live in it.

repository: mdashx/basicwebtheme

repo_name: mdashx/basicwebtheme


text:
# Software

## Linux Tutorials
- If you are a beginner then you must go through [Linux Journey](https://linuxjourney.com/) website. It is an intutive website which covers all the basic commands.
- [Linux productivity tips: "Missing Semester" from MIT](https://www.youtube.com/playlist?list=PLyzOVJj3bHQuloKGG59rS43e29ro7I57J) is good for people who like video lectures. After doing this course, you will have good working knowledge of Linux.
- [Org Mode Intro: Execellent note taking tool in emacs](https://www.youtube.com/watch?v=S4f-GUxu3CY&t=121s)
- [Tiling Window Managers: Tmux for all windows beyond the terminal!](https://www.youtube.com/watch?v=j1I63wGcvU4&list=PL5ze0DjYv5DbCv9vNEzFmP6sU7ZmkGzcf)

## Books
- [How Linux Works – What Every Superuser Should Know](https://www.amazon.in/How-Linux-Works-Superuser-Should/dp/1593275676#:~:text=In%20this%20completely%20revised%20second,workings%20of%20the%20operating%20system.&text=How%20Linux%20boots%2C%20from%20boot,%2C%20Upstart%2C%20and%20System%20V))

## Tips
- Linux is something which you cant learn through books alone. Keep using linux as much as possible and try to do everything on terminal alone.
- We would recommend installing Ubuntu 18.04 LTS for best experience.

repository: aditya-shirwatkar/resources

repo_name: aditya-shirwatkar/resources