text:
Master: [![Build Status](https://travis-ci.org/usdot-jpo-ode/jpo-ode.svg?branch=master)](https://travis-ci.org/usdot-jpo-ode/jpo-ode) [![Quality Gate](https://sonarcloud.io/api/badges/gate?key=usdot.jpo.ode:jpo-ode)](https://sonarcloud.io/dashboard?id=usdot.jpo.ode%3Ajpo-ode)

Develop: [![Build Status](https://travis-ci.org/usdot-jpo-ode/jpo-ode.svg?branch=develop)](https://travis-ci.org/usdot-jpo-ode/jpo-ode) [![Quality Gate](https://sonarcloud.io/api/badges/gate?key=usdot.jpo.ode:jpo-ode:develop)](https://sonarcloud.io/dashboard?id=usdot.jpo.ode%3Ajpo-ode%3Adevelop)

# jpo-ode
US Department of Transportation (USDOT) Intelligent Transportation Systems Operational Data Environment (ITS ODE)

The ITS ODE is a real-time virtual data router that ingests and processes operational data from various connected devices - including vehicles, infrastructure, and traffic management centers - and distributes it to other devices and subscribing transportation management applications. Using the ITS ODE within intelligent transportation deployments increases data fluidity and interoperability while meeting operational needs and protecting user privacy. The software’s microservices architecture makes it easy to add new capabilities to meet local needs.

![ODE Dataflows](images/data_flow_v2.png)

## Table of Contents

[I. Release Notes](#release-notes)

[II. Documentation](#documentation)

[III. Collaboration Tools](#collaboration-tools)

[IV. Getting Started](#getting-started)

[V. Testing the Application](#testing)

[VI. ODE Limitation](#dev-tools)

[VII. Development Tools](#dev-tools)

[VIII. Contribution Information](#contribution-info)

[IX. Troubleshooting](#troubleshooting)

---

## [I. Release Notes](ReleaseNotes.md)

## II. Documentation
ODE provides the following living documents to keep ODE users and stakeholders informed of the latest developments:

1. [ODE Architecture](docs/JPO%20ODE%20Architecture.docx)
2. [ODE User Guide](docs/JPO_ODE_UserGuide.docx)
3. [ODE Output Schema Reference Guide](docs/ODE_Output_Schema_Reference.docx)
4. [ODE REST API Guide](https://usdot-jpo-ode.github.io/)
5. [ODE Smoke Tests](https://github.com/usdot-jpo-ode/jpo-ode/wiki/JPO-ODE-QA-Documents)

All stakeholders are invited to provide input to these documents. Stakeholders should direct all input on this document to the JPO Product Owner at DOT, FHWA, and JPO. To provide feedback, we recommend that you create an "issue" in this repository (https://github.com/usdot-jpo-ode/jpo-ode/issues). You will need a GitHub account to create an issue. If you don’t have an account, a dialog will be presented to you to create one at no cost.

## III. Collaboration Tools

### Source Repositories - GitHub
- Main repository on GitHub (public)
	- https://github.com/usdot-jpo-ode/jpo-ode
	- git@github.com:usdot-jpo-ode/jpo-ode.git
- Security repository on GitHub (public)
        - https://github.com/usdot-jpo-ode/jpo-security.git
	- git@github.com:usdot-jpo-ode/jpo-security.git
- Private repository on BitBucket
	-<EMAIL_ADDRESS>	- git@bitbucket.org:usdot-jpo-ode/jpo-ode-private.git
- Data Privacy Module on Github (public)
	- https://github.com/usdot-jpo-ode/jpo-cvdp
	-<EMAIL_ADDRESS>- S3 Depositor Module on Github (public)
	- https://github.com/usdot-jpo-ode/jpo-s3-deposit
	-<EMAIL_ADDRESS>
### Agile Project Management - Jira
https://usdotjpoode.atlassian.net/secure/Dashboard.jspa

### Wiki - Confluence
https://usdotjpoode.atlassian.net/wiki/

### Continuous Integration and Delivery
https://travis-ci.org/usdot-jpo-ode/jpo-ode

To allow Travis run your build when you push your changes to your public fork of the jpo-ode repository, you must define the following secure environment variable using Travis CLI (https://github.com/travis-ci/travis.rb).

Run:

```
travis login --org
```
Enter personal github account credentials and then run this:

```
travis env set BITBUCKET_UN_APP_PW 'yourbitbucketusername:yourbitbucketpassword' -r yourtravisusername/jpo-ode
```

The login information will be saved and this needs to be done only once.

In order to allow Sonar to run, personal key must be added with this command:
(Key can be obtained from the JPO-ODE development team)

```
travis env set SONAR_SECURITY_TOKEN <key> -pr <user-account>/<repo-name>
```

### Static Code Analysis
https://sonarcloud.io/organizations/usdot-jpo-ode/projects

[Back to top](#toc)

## IV. Getting Started

The following instructions describe the procedure to fetch, build, and run the application. If you are installing the ODE in an Ubuntu environment, see this [quick start guide](https://github.com/usdot-jpo-ode/jpo-ode/wiki/Prepare-a-fresh-Ubuntu-instance-for-ODE-installation).

### Prerequisites
* JDK 1.8: http://www.oracle.com/technetwork/pt/java/javase/downloads/jdk8-downloads-2133151.html
* Maven: https://maven.apache.org/install.html
* Git: https://git-scm.com/

Additionally, read the following guides to familiarize yourself with Docker and Kafka.

**Docker**

[README.md](docker/README.md)

**Kafka**

[README.md](docker/kafka/README.md)

---
### Obtain the Source Code

**NOTE**: The ODE consists of four repositories:

|Name|Visibility|Description|
|----|----------|-----------|
|[jpo-ode](https://github.com/usdot-jpo-ode/jpo-ode)|public|Contains the public components of the application code.|
|[jpo-cvdp](https://github.com/usdot-jpo-ode/jpo-cvdp)|public|Privacy Protection Module|
|[jpo-s3-deposit](https://github.com/usdot-jpo-ode/jpo-s3-deposit)|public|S3 depositor service. Optional, comment out of `docker-compose.yml` file if not used.|
|[jpo-security](https://github.com/usdot-jpo-ode/jpo-security)|public|Security dependencies.|
|[asn1_codec](https://github.com/usdot-jpo-ode/asn1_codec)|public|ASN.1 Encoder/Decoder module|
|jpo-ode-private|private|Proprietary dependencies.|
|[jpo-security-svcs](https://github.com/usdot-jpo-ode/jpo-security-svcs)|public|Provides cryptographic services.|

Building this application requires all repositories. If you need access to the private repositories, please reach out to a member of the development team.

#### Step 1 - Clone public repository

Disable Git core.autocrlf (Only the First Time)
**NOTE**: If running on Windows, please make sure that your global git config is set up to not convert End-of-Line characters during checkout. This is important for building docker images correctly.

```bash
git config --global core.autocrlf false
```

Clone the source code from the GitHub repository using Git command:

```bash
git clone --recurse-submodules https://github.com/usdot-jpo-ode/jpo-ode.git
```

*Note*: Make sure you specify the --recurse-submodules option on the clone command line. This option will cause the cloning of all dependent submodules:
- Privacy Protection Module (PPM) - [jpo-cvdp](https://github.com/usdot-jpo-ode/jpo-cvdp)
- S3 Bucket Depositor - [jpo-s3-deposit](https://github.com/usdot-jpo-ode/jpo-s3-deposit)
- Security - [jpo-security](https://github.com/usdot-jpo-ode/jpo-security)
- Security Services Module- [jpo-security](https://github.com/usdot-jpo-ode/jpo-security-svcs)
- ASN.1 CODEC - [asn1_codec](https://github.com/usdot-jpo-ode/asn1_codec)

#### Step 2 - Clone private repository

Clone the source code from the BitBucket repository:

```bash
git clone --recurse-submodules<EMAIL_ADDRESS>```

---
### Build and Deploy the Application

#### Environment Variables

ODE configuration can be customized for every deployment environment using environment variables. These variables can either be set locally or using the *sample.env* file found in the root of the jpo-ode repository.

Instructions for how to use the *sample.env* file can be found [here](https://github.com/usdot-jpo-ode/jpo-ode/wiki/Using-the-.env-configuration-file).

**Important!**
You must rename `sample.env` to `.env` for Docker to automatically read the file. This file will contain AWS access keys and other private information. Do not push this file to source control.

#### Build Process

**Note** Docker builds may fail if you are on a corporate network due to DNS resolution errors.
[See here](https://github.com/usdot-jpo-ode/jpo-ode/wiki/Docker-fix-for-SSL-issues-due-to-corporate-network) for instructions to fix this.

**Note** In order for Docker to automatically read the environment variable file, you must rename it from `sample.env` to `.env`.

The ODE application uses Maven to manage builds.

**Step 1**: Build the private repository artifacts consisting of J2735 ASN.1 Java API and IEEE1609.2 ASN.1 Java API

Navigate to the root directory of the `jpo-ode-private` project:

```bash
 cd jpo-ode-private/
 mvn clean install
```

**Step 2**: Build the public 1609.2 Security Library
```bash
cd jpo-security
mvn clean install -DskipTests
```

**Step 3**: Build the S3 Bucket Depositor Service

Note - if you do not intend on using this feature, edit the docker-compose.yml file and comment out (add a `#` to) the lines including and below `s3dep:`.

Navigate to the root directory of the `jpo-s3-depositor` project:

```bash
mvn clean compile assembly:single install
```

**Step 4** (Optional)
Familiarize yourself with Docker and follow the instructions in the [README.md](docker/README.md).

If you wish to change the application properties, such as change the location of the upload service via `ode.uploadLocation.*` properties or set the `ode.kafkaBrokers` to something other than the $DOCKER_HOST_IP:9092, or wish to set the CAS username/password, `ODE_EXTERNAL_IPVs`, etc. instead of setting the environment variables, modify `jpo-ode-svcs\src\main\resources\application.properties` file as desired.

**Step 5**: Navigate to the root directory of the jpo-ode project.

**Step 6**: Build and deploy the application.

The easiest way to do this is to run the ```clean-build-and-deploy``` script.
This script executes the following commands:

```
#!/bin/bash
docker-compose stop
docker-compose rm -f -v
mvn clean install
docker-compose up --build -d
docker-compose ps
```

For other build options, see the next section. Otherwise, move on to section [V. Testing ODE Application](#testing)

[Back to top](#toc)

---
### Other Build/Deploy Options

#### Building ODE without Deploying
To build the ODE docker container images but not deploy it, run the following commands:

```
 cd jpo-ode (or cd ../jpo-ode if you are in any sub-directory)
 mvn clean install
 docker-compose rm -f -v
 docker-compose build
```

Alternatively, you may run the ```clean-build``` script.

#### Deploying ODE Application on a Docker Host
To deploy the the application on the docker host configured in your DOCKER_HOST_IP machine, run the following:

```bash
docker-compose up --no-recreate -d
```

**NOTE**: It's important to run ```docker-compose up``` with ```no-recreate``` option. Otherwise you may run into [this issue] (https://github.com/wurstmeister/kafka-docker/issues/100).

Alternatively, run ```deploy``` script.

Check the deployment by running ```docker-compose ps```. You can start and stop containers using ```docker-compose start``` and ```docker-compose stop``` commands.
If using the multi-broker docker-compose file, you can change the scaling by running ```docker-compose scale <container>=n``` where container is the container you would like to scale and n is the number of instances. For example, ```docker-compose scale kafka=3```.

#### Running ODE Application on localhost
You can run the application on your local machine while other services are deployed on a host environment. To do so, run the following:
```bash
 docker-compose start zookeeper kafka
 java -jar jpo-ode-svcs/target/jpo-ode-svcs-0.0.1-SNAPSHOT.jar
```

[Back to top](#toc)

## V. Testing ODE Application
Once the ODE is running, you should be able to access the jpo-ode web UI at `localhost:8080`.

1. Press the `Connect` button to connect to the ODE WebSocket service.
2. Press `Choose File` button to select an OBU log file containing BSMs and/or TIM messages as specified by the WYDOT CV Pilot project. See below documents for details:
a. [Wyoming CV Pilot Log File Design](data/Wyoming_CV_Pilot_Log_File_Design.docx)
b. [WYDOT Log Records](data/wydotLogRecords.h)
3. Press `Upload` button to upload the file to ODE.

Upload records within the files must be embedding BSM and/or TIM messages wrapped in J2735 MessageFrame and ASN.1 UPER encoded, wrapped in IEEE 1609.2 envelope and ASN.1 COER encoded binary format. The following files are a samples of each supported type. Uploading any of the files below will you will observe the decoded messages returned to the web UI page while connected to the WebSocket interface:

 - [data/bsmLogDuringEvent.bin](data/bsmLogDuringEvent.bin)
 - [data/bsmLogDuringEvent.gz](data/bsmLogDuringEvent.gz)
 - [data/bsmTx.bin](data/bsmTx.bin)
 - [data/bsmTx.gz](data/bsmTx.gz)
 - [data/dnMsg.bin](data/dnMsg.bin)
 - [data/dnMsg.gz](data/dnMsg.gz)
 - [data/rxMsg_BSM.bin](data/rxMsg_BSM.bin)
 - [data/rxMsg_BSM.gz](data/rxMsg_BSM.gz)
 - [data/rxMsg_TIM.bin](data/rxMsg_TIM.bin)
 - [data/rxMsg_TIM.gz](data/rxMsg_TIM.gz)

Another way data can be uploaded to the ODE is through copying the file to the location specified by the `ode.uploadLocationRoot/ode.uploadLocationObuLog`property. If not specified,  Default locations would be `uploads/bsmlog`sub-directory off of the location where ODE is launched.

The result of uploading and decoding of messages will be displayed on the UI screen.

![ODE UI](images/ode-ui.png)

*Notice that the empty fields in the J2735 message are represented by a `null` value. Also note that ODE output strips the MessageFrame header and returns a pure BSM or TIM in the subscription topic.*

### asn1_codec Module (ASN.1 Encoder and Decoder)
ODE requires the deployment of asn1_codec module. ODE's `docker-compose.yml` file is set up to build and deploy the module in a Docker container. If you wish to run `asn1_codec` module outside Docker (i.e. directly on the host machine), please refer to the documentation of `asn1_codec` module.

The only requirement for deploying `asn1_codec` module on Docker is the setup of two environment variables `DOCKER_HOST_IP` and `DOCKER_SHARED_VOLUME`.

### PPM Module (Geofencing and Filtering)

To run the ODE with PPM module, you must install and start the PPM service. PPM service communicates with other services through Kafka Topics. PPM will read from the specified "Raw BSM" topic and publish the result to the specified "Filtered Bsm" topic. These topic names are specified by the following ODE and PPM properties:

 - ODE properties for communications with PPM (set in application.properties)
	 - ode.kafkaTopicBsmRawJson  (default = j2735BsmRawJson)
	 - ode.kafkaTopicBsmFilteredJson (default = j2735BsmFilteredJson)
 - PPM properties for communications with ODE (set in yourconfig.properties)
	 - privacy.topic.consumer (default = j2735BsmRawJson)
	 - privacy.topic.producer (default = j2735BsmFilteredJson)

Follow the instructions [here](https://github.com/usdot-jpo-ode/jpo-cvdp/blob/master/docs/installation.md) (https://github.com/usdot-jpo-ode/jpo-cvdp/blob/master/docs/installation.md) to install and build the PPM service.

During the build process, edit the sample config file located in `config/example.properties` and point the property `metadata.broker.list` towards the host of your docker machine or wherever the kafka brokers are hosted. You may use the command `docker-machine ls` to find the kafka service.

After a successful build, use the following commands to configure and run the PPM

```
cd $BASE_PPM_DIR/jpo-cvdp/build
$ ./bsmjson_privacy -c ../config/ppm.properties
```
With the PPM module running, all filtered BSMs that are uploaded through the web interface will be captured and processed. You will see an output of both submitted BSM and processed data unless the entire record was filtered out.

![PPM](images/PPM.png)

[Back to top](#toc)

## VI. ODE Limitations

Date: 07/2017

In its current state, the ODE has been developed to accomplish the goals of data transfer, security, and modularity working with the J2735 and 1609.2 security. The system has been designed to support multiple services orchestrated through the Apache Kafka streaming data pipelines, services built and supported as separate applications and described with each service's repository. As a modular system, each component has been built for functionality first, and additional performance testing is needed to understand the limits of the system with large volumes of data.

## VII. Development Tools

### Integrated Development Environment (IDE)

Install the IDE of your choice:

* Eclipse: [https://eclipse.org/](https://eclipse.org/)
* STS: [https://spring.io/tools/sts/all](https://spring.io/tools/sts/all)
* IntelliJ: [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/)

### Continuous Integration and Delivery

To be added.

### Continous Deployment

To be added.

## VIII. Contribution Information

Please read our [contributing guide](docs/contributing_guide.md) to learn about our development process, how to propose pull requests and improvements, and how to build and test your changes to this project.

## IX. Troubleshooting

Please read our [Wiki](https://github.com/usdot-jpo-ode/jpo-ode/wiki) for more information, or check the [ODE User Guide](https://github.com/usdot-jpo-ode/jpo-ode/raw/develop/docs/JPO_ODE_UserGuide.docx).

[Back to top](#toc)

repository: hmusavi/jpo-ode

branch_name: refs/heads/develop

repo_name: hmusavi/jpo-ode


text:
# RZSquaresLoading binding for Xamarin iOS
This is a Xamarin C# binding on [RZSquaresLoading](https://github.com/robinzhangx/RZSquaresLoading),
a loading animation with squares.

This project contains:

- A git submodule to the version of RZSquaresLoading used to create the binding
- A Xcode project to build RZSquaresLoading as a static library
- A Xamarin project to build the binding

The latest dll is directly available [here](https://github.com/Backelite/RZSquaresLoading-Xamarin-iOS/blob/master/Binding/RZSquaresLoading/bin/Release/RZSquaresLoading.dll?raw=true).

It is 32-bits only for the moment.

## Usage
Include the dll in your Xamarin iOS project, the Api is available under the RZSquaresLoadingNamespace namespace.

## Documentation
See [RZSquaresLoading](https://github.com/robinzhangx/RZSquaresLoading).

## Contributing

Contributions for bug fixing or improvements are welcomed. Feel free to submit a pull request.

## License
RZSquaresLoading for Xamarin iOS is available under the MIT license. See the LICENSE file for more info.

license: MIT

repository: Backelite/RZSquaresLoading-Xamarin-iOS

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Backelite/RZSquaresLoading-Xamarin-iOS


text:
# UXL Localization [![npm version](https://badge.fury.io/js/%40uxland%2Flocalization.svg)](https://badge.fury.io/js/%40uxland%2Flocalization)

| Build Status                                    | Statements                                    | Branches                                  | Functions                                   | Lines                               |
| ----------------------------------------------- | --------------------------------------------- | ----------------------------------------- | ------------------------------------------- | ----------------------------------- |
| ![BuildStatus](#buildstatus# 'Building Status') | ![Statements](#statements# 'Make me better!') | ![Branches](#branches# 'Make me better!') | ![Functions](#functions# 'Make me better!') | ![Lines](#lines# 'Make me better!') |

## Installation

`npm i @uxland/localization`

## Usage

A default mixin is provided in order to be able to use localization functionalities and subscribe to language and locales changes.

```typescript
export class Klass implements locale(BaseKlass) {}
```

In order to use custom formats in localization, define a new mixin provinding a factory including the desired formats.

```typescript
const customLocale = localeMixin(() =>
  localizerFactory('en', {}, { number: { EUR: { style: 'currency', currency: 'EUR' } } })
);

export class Klass implements customLocale(BaseKlass) {}
```

### Update current language

Set the current language that will be used in order to retrieve proper localization. Each time locales are updated, the event `LANGUAGE_UPDATED` will be published in order to inform all subscribers that the language has changed

```typescript
setLanguage('en');
```

To retrieve current language from anywhere in the code, use:

```typescript
getLanguage();
```

It is possible to reset locales to its default. This action will publish a `LANGUAGE_RESET` event.

```typescript
resetLanguage();
```

> By default, language is set to english `en`.

### Update current formatters

Set the current formatters that will be used in order to retrieve proper localization. Each time locales are updated, the event `FORMATTERS_UPDATED` will be published in order to inform all subscribers that the formatters has changed.

> Formatters must follow

```typescript
setFormatters({ number: { EUR: { style: 'currency', currency: 'EUR' } } });
```

To retrieve current formatters from anywhere in the code, use:

```typescript
getFormatters();
```

It is possible to reset locales to its default. This action will publish a `FORMATTERS_RESET` event.

```typescript
resetFormatters();
```

### Set locales dictionary

Locales must follow the next format:

```typescript
const locales = [language]: {
		foo: {
			title: 'Title',
			subtitle: 'Subtitle'
		}
	};
```

Each time locales are updated, the event `LOCALES_UPDATED` will be published in order to inform all subscribers that the locales dictionary has changed.

```typescript
setLocales(locales);
```

To retrieve current locales dictionary, use:

```typescript
getLocales();
```

It is possible to reset locales to its default dictionary. This action will publish a `LOCALES_RESET` event.

```typescript
resetLocales();
```

### Localize

When localizing, the current language is used to retrieve language's locales. Providing a path to the `localize` function, this will return the corresponding string defined in locales dictonary.

```typescript
const locales = [language]: {
		foo: {
			title: 'Title',
			subtitle: 'Subtitle',
			greetings: 'Hi!'
		}
	};
setLocales(locales);
localize(`foo.title`); // => "Title"
```

Arguments can also be provided to `localize` in order to get dynamic locales as it is specified bellow:

```typescript
const locales = [language]: {
		foo: {
			title: 'Title',
			subtitle: 'Subtitle',
			greetings: 'Hi {name}!'
		}
setLocales(locales);
localize(`foo.greetings`, 'id', 'John Doe'); // => "Hello John Doe"
localize(`foo.greetings`, {id: 'John Doe'}); // => "Hello John Doe"
```

It is also possible to use pluralization as follows:

```typescript
const locales = [language]: {
		foo: {
			title: 'Title',
			subtitle: 'Subtitle',
			greetings: 'Hi {name}!',
			cats: '{cats, plural, =0 {No cats} =1 {A cat} other {# cats}}'
		}
setLocales(locales);
localize(`foo.cats`, 'cats', 0); // => "No cats"
localize(`foo.cats`, 'cats', 1); // => "A cat"
localize(`foo.cats`, 'cats', 3); // => "3 cats"
```

Also currency can be localized as follows:

```typescript
const locales = [language]: {
		foo: {
			title: 'Title',
			subtitle: 'Subtitle',
			greetings: 'Hi {name}!',
			cats: '{cats, plural, =0 {No cats} =1 {A cat} other {# cats}}',
			salary: 'Your salary is {salary, number, EUR}'
		}
setLocales(locales);
setFormatters({
        number: { EUR: { style: 'currency', currency: 'EUR' } },
      });
localize(`foo.salary`, { salary: 2000 }); // => "Your salary is €2,000.00"
```

repository: uxland/uxland

gha_language: TypeScript

gha_license_id: NOASSERTION

repo_name: uxland/uxland


text:
# Augmented Analytics

[Augmented analytics](https://www.tableau.com/learn/articles/augmented-analytics) is a class of analytics powered by artificial intelligence (AI) and machine learning (ML) that expands a human’s ability to interact with data at a contextual level. We use AI to make analytics accessible so that more people can confidently explore and interact with data to drive meaningful decisions. From automated modeling to guided natural language queries, our augmented analytics capabilities are powerful and trusted to help organizations leverage their growing amount of data and empower a wider business audience to discover insights.

- Ask data
- Explain data
- Einstein discovery for reports
- Data stories
- Forecasting
- Predictive modeling functions

### What are the benefits of augmented analytics?

- Agility: Increasing speed to insight
- Accuracy: Providing a more complete picture
- Efficiency: Automating operational tasks
- Confidence: Powerful analysis in context

### Augmented Analytics Features

- Automatic data identification
- Statistical techniques
- Smart data prep
- Recommendations
- Natural language interactions

[Augmented Analytics Explained | Tableau](https://www.tableau.com/learn/articles/augmented-analytics)

[Tableau Augmented Analytics](https://www.tableau.com/solutions/ai-analytics/augmented-analytics)

[Tableau AI analytics](https://www.tableau.com/solutions/ai-analytics)

[Augmented Analytics with Tableau](https://www.tableau.com/learn/webinars/augmented-analytics-tableau)

[Augmented Analytics with Tableau - Ask Data & Explain Data](https://www.tableau.com/learn/webinars/augmented-analytics-with-tableau-ask-data-explain-data)

[Introducing Databricks Assistant, a context-aware AI assistant | Databricks Blog](https://www.databricks.com/blog/introducing-databricks-assistant)

[Introducing LakehouseIQ: The AI-Powered Engine that Uniquely Understands Your Business | Databricks Blog](https://www.databricks.com/blog/introducing-lakehouseiq-ai-powered-engine-uniquely-understands-your-business)

## Others

[Zenlytic | Business Intelligence you can talk to](https://www.zenlytic.com/)

[June - Product analytics for B2B SaaS](https://www.june.so/ai)

gha_language: JavaScript

gha_license_id: MIT


text:
# CSS Border
* **objective:** learn how to define border around an element using CSS.

### CSS Border Properties
The CSS border properties allow you to define the border area of an element's box.

Borders appear directly between the margin and padding of an element. The border can either be a predefined style like, solid line, dotted line, double line, etc. or an image.

### Understanding the Different Border Styles

The `border-style` property sets the style of a box's border such as: solid, dotted, etc. It is a shorthand property for setting the line style for all four sides of the elements border.

The border-style property can have the following values: `none`, `hidden`, `solid`, `dashed`, `dotted`, `double`, `inset`, `outset`, `groove`, and `ridge`.

An illustration of how the border styles would look like:

![Border property illustration](https://www.tutorialrepublic.com/lib/images/css-border-style.png)

The values `none` and `hidden` displays no border, however, there is a slight difference between these two values. In the case of table cell and border collapsing, the `none` value has the lowest priority, whereas the `hidden` value has the highest priority, if any other conflicting border is set.

The values `inset`, `outset`, `groove`, and `ridge` creates a 3D like effect which essentially depends on the `border-color` value.

`Example`
```css
h1 {
    border-style: dotted;
}
p {
    border-style: ridge;
}
```
---
### Setting the Border Width
The `border-width` property specifies the width of the border area. It is a shorthand property for setting the thickness of all the four sides of an element's border at the same time.

`Example`
```css
p {
    border-style: dashed;
    border-width: 10px;
}
```
> **Note:** The border width can be specified using any length value, such as px, em, rem, and so on. In addition to length units, the border width may also be specified using one of three keywords: `thin`, `medium`, and `thick`. Percentage values are not allowed.
---
### Specifying the Border Color
The `border-color` property specifies the color of the border area. This is also a shorthand property for setting the color of all the four sides of an element's border.

`Example`
```css
p {
    border-style: solid;
    border-color: #ff0000;
}

```
>**Note:** The CSS `border-width` or `border-color` property does not work if it is used alone. Use the `border-style` property to set the style of the border first.
---
### Border Shorthand Property
The `border` CSS property is a shorthand property for setting one or more of the individual border properties `border-width`, `border-style` and `border-color` in a single rule.

`Example`
```css
p {
    border: 5px solid #00ff00;
}
```

If the value for an individual border property is omitted or not specified while setting the border shorthand property, the default value for that property will be used instead, if any.

in the case of `border-style`, omitting the value will cause no border to show at all, because the default value for this property is none.

`Example`
```css
p {
    border: 5px #00ff00;
}
```
---

path: /CSS Box Model/CSS border.md

filename: CSS border.md


text:
# StripHTML

[![Version](https://img.shields.io/cocoapods/v/StripHTML.svg?style=flat)](http://cocoapods.org/pods/StripHTML)
[![License](https://img.shields.io/cocoapods/l/StripHTML.svg?style=flat)](http://cocoapods.org/pods/StripHTML)
[![Platform](https://img.shields.io/cocoapods/p/StripHTML.svg?style=flat)](http://cocoapods.org/pods/StripHTML)

## Overview
StripHTML is a category of NSString, written in Objective-c, that remove tags from an HTML string.

## Usage

```Objective-C
#import <StripHTML/NSString+StripHTML.h>

NSString *htmlString = @"<p> This is a string with tags <p>";
NSString *taglessString = [htmlString removeTags];
```

## Example Project

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

## Requirements

StripHTML supports iOS 8.3+.

## Installation

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

```ruby
pod "StripHTML"
```

## Author

Bruno Rendeiro

## License

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

repository: brurend/StripHTML

repo_name: brurend/StripHTML


text:
# react-livestream

Automatically embed your livestream in your React app whenever you go live!

This package currently works with the following streaming platforms:

1. [Twitch](https://www.twitch.tv/)
2. [Mixer](https://www.mixer.com/)
3. [YouTube](https://www.youtube.com/)

### Instructions

`react-livestream` allows you to use a React component called `<ReactLivestream />`, which will embed a responsive `<iframe>` into your site whenever your channel or account is live.

If you are not currently broadcasting, nothing will be rendered in the DOM unless you choose to pass in an optional JSX element as the `offlineComponent` prop. In this case, that component will render when you're offline.

```javascript
import React from 'react'
import ReactLivestream from 'react-livestream'

// Optional component to be rendered
// when you're not streaming
function OfflineComponent() {
  return (
    <div>
      <p>I am offline now, but checkout my stream on Fridays at 5 PM EST</p>
    </div>
  )
}

function App() {
  return (
    <div className="App">
      <ReactLivestream
        mixerChannelId
        offlineComponent
        platform
        twitchClientId
        twitchUserName
        youtubeApiKey
        youtubeChannelId
      />
    </div>
  )
}

export default App
```

The component takes these general props:

- `platform` - "mixer", "twitch", or "youtube" (required)
- `offlineComponent` - A JSX element that renders in place of the `<iframe>` when the user is **not** live (optional)

In addition, you need to pass in the following information based on your streaming platform:

- `mixerChannelId` - Found in the Network tab of your developer tools when navigating to your Mixer channel. For example, mine is `https://mixer.com/api/v1/channels/102402534`, so my ID is `102402534`
- `twitchClientId` - Configure this in your Twitch Developer portal
- `twitchUserName` - The username associated with your Twitch account
- `youtubeApiKey` - Obtain this from the Google Developers console
- `youtubeChannelId` - This can be found in the URL to you YouTube channel. For example, my channel URL is `https://www.youtube.com/channel/UCwMTu04flyFwBnLF0-_5H-w`, so my channel ID is `UCwMTu04flyFwBnLF0-_5H-w`

### Examples

Currently, it works with the three streaming services mentioned above. Below, are examples of how to use this component for each streaming platform.

**Mixer**

```javascript
<ReactLivestream platform="mixer" mixerChannelId={102402534} />
```

**Twitch**

```javascript
<ReactLivestream
  platform="twitch"
  twitchClientId={'API_KEY_HERE'}
  twitchUserName="ryan_c_harris"
/>
```

**YouTube**

```javascript
<ReactLivestream
  platform="youtube"
  youtubeApiKey={'API_KEY_HERE'}
  youtubeChannelId="UCwMTu04flyFwBnLF0-_5H-w"
/>
```

### Notes

Built with [React](https://github.com/facebook/react) and [Rollup](https://github.com/rollup/rollup).

Maintained by [Ryan Harris](https://ryanharris.dev)


text:
# FAQ

Here are the frequently asked questions about Ant Design Vue that you should look up before you ask in community or create new issue.

### Are you going to provide Sass/Stylus(etc...) style file?

No, actually, you can convert Less to Sass/Stylus(etc...) with tools (which you can Google).

### How to use DatePicker with dayjs

We also provide another implementation, which we provide with antd-dayjs-webpack-plugin, replacing dayjs with Day.js directly without changing a line of existing code. More info can be found at [antd-dayjs-webpack-plugin](https://github.com/ant-design/antd-dayjs-webpack-plugin).

### Internationalization does not take effect?

The language pack provided by the component does not affect date formatting. You need to import the dayjs language pack and apply it. Refer to the `ConfigProvider` component.

### `Select Dropdown DatePicker TimePicker Popover Popconfirm` disappear when I click another popup component inside it, How to resolve it?

Use `<a-select :getPopupContainer="trigger => trigger.parentNode">` to render component inside Popover. (Or other getXxxxContainer props)

### `Select Dropdown DatePicker TimePicker Popover Popconfirm` scroll with the page?

Use `<a-select :getPopupContainer="trigger => trigger.parentNode">` to render component inside the scroll area. (Or other getXxxxContainer props).

### How to modify the default theme of Ant Design Vue?

See [Customize Theme](/docs/vue/customize-theme/).

### It doesn't work when I change `defaultValue`,`defaultOpenKeys`, `initialValue` dynamically.

The `defaultXxxx` (like `defaultValue`) of `Input`/`Select`(etc...) only works in first render. This feature is referenced from [React](https://facebook.github.io/react/docs/forms.html#controlled-components).

### I set the `value` of `Input`/`Select`(etc...), and then, it cannot be changed by user's action.

Try `defaultValue` or `change` or `v-model` to change `value`.

### ant-design-vue override my global styles!

Yes, ant-design-vue is designed to develop a complete background application, we override some global styles for styling convenience, and it can't be removed now. More info trace https://github.com/ant-design/ant-design/issues/4331 .

Or, follow the instructions in [How to avoid modifying global styles?](docs/react/customize-theme#How-to-avoid-modifying-global-styles-?)

### `ant-design-vue` makes only poor user experience on mobile.

`ant-design-vue` is not designed for mobile.

### When I set `mode` to DatePicker/RangePicker, I cannot select year or month anymore?

In a real world development, you may need a YearPicker, MonthRangePicker or WeekRangePicker. You are trying to add `mode` to DatePicker/RangePicker expected to implement those pickers. However, the DatePicker/RangePicker cannot be selected and the panels won't close now.

That is because `<DatePicker mode="year" />` do not equal to `YearPicker`, `<RangePicker mode="month" />` do not equal to `MonthRangePicker` either. The `mode` property was added to support [showing time picker panel in DatePicker](https://github.com/ant-design/ant-design/issues/5190), which simply control the displayed panel and won't change the original date picking behavior of `DatePicker/RangePicker` (for instance you still need to click date cell to finish selection in a DatePicker, whatever the `mode` is).

##### Solution

The following articles are the implementation articles of the react version, the ideas are the same. In [one article](https://juejin.im/post/5cf65c366fb9a07eca6968f9) or [another article](https://www.cnblogs.com/zyl-Tara/p/10197177.html) approach, using methods `mode` and `panelChange` to encapsulate a component such as `YearPicker`. We plan to add more date related components directly in<EMAIL_ADDRESS>to support these needs.

repository: vueComponent/ant-design-vue

branch_name: refs/heads/main

gha_language: Vue

repo_name: vueComponent/ant-design-vue


text:
---

title: CLI
layout: col-document
tags: threatdragon
document: Threat Dragon version 2.0
permalink: /docs-2/cli/

---

{% include breadcrumb.html %}

## [OWASP](https://www.owasp.org) Threat Dragon

With the desktop version of [Threat Dragon](http://owasp.org/www-project-threat-dragon) installed,
and if the executable is in the environment path, then Threat Dragon can be run from the command line.

For example after install on MacOS and Linux:

`OWASP-Threat-Dragon`

or after install on Windows:

`OWASP-Threat-Dragon.exe`

AppImage does not need installation, so after downloading version 1.3.1 (for example) just run:

`./OWASP-Threat-Dragon-1.3.1.AppImage`

There is also a command line interface which can be used (again if the executable is in the environment path)
to directly access some of Threat Dragon's functionality.
For example run this command to get help :

`OWASP-Threat-Dragon --help`

Or to export a given threat model file to pdf :

`OWASP-Threat-Dragon --pdf ./threat-model.json --verbose`

If on Windows:

`OWASP-Threat-Dragon.exe --pdf .\threat-model.json --verbose`

or using AppImage (using version 1.3.1 for example):

`./OWASP-Threat-Dragon-1.3.1.AppImage --pdf ./threat-model.json --verbose`

*Note* that the path to the JSON file needs to be resolvable, so use the full path
or the './' if the file is in the working directory.

Here is the help contents for version 1.3.1 :

```text
OWASP-Threat-Dragon --help
Usage: OWASP-Threat-Dragon <command> [options]

Commands:
  OWASP-Threat-Dragon edit <json>   Edit JSON threat model          [aliases: e]
  OWASP-Threat-Dragon open <json>   Open JSON threat model          [aliases: o]
  OWASP-Threat-Dragon pdf <json>    Export JSON threat model as PDF [aliases: p]
  OWASP-Threat-Dragon print <json>  Print JSON threat model         [aliases: p]
  OWASP-Threat-Dragon run           Run threat dragon application[aliases: r, x]

Options:
  --version      Show version number                                   [boolean]
  --verbose, -v  Increasing levels of verbosity                          [count]
  --help         Show help                                             [boolean]
```

Verbosity can be increased from the default of 'error':

`-v` warnings and info

`-vv` verbose and debug

`-vvv` silly

repository: OWASP/www-project-threat-dragon

gha_language: HTML

repo_name: OWASP/www-project-threat-dragon


text:
Cipex-Analyse
=============

Introduction
------------

Cipex-Analyse is a Hadoop Job for analysing Cipex output tables.

Installation
------------

    cd cipex-analyse
    mvn install

Usage
-----

The command line application is executed by typing

    hadoop -jar
      target/cipex-analyse-1.0-SNAPSHOT-jar-with-dependencies.jar
      -d /path/to/hdfs/directory/

where

    -d,--dir <arg>    HDFS directory containing cipex output data.

Additional hadoop parameters must be defined after the jar parameter, e.g.
setting the maximum number of tasks that should run in parallel:

    hadoop jar
      target/cipex-1.0-SNAPSHOT-jar-with-dependencies.jar
      -Dmapred.tasktracker.map.tasks.maximum=2
      -d /path/to/hdfs/input/directory

repository: shsdev/cipex-analyse

gha_language: Java

repo_name: shsdev/cipex-analyse


text:
gluster-client Cookbook
=======================
Installs glusterfs native client packages and mounts volumes.

Requirements
------------
* [yum](https://supermarket.chef.io/cookbooks/yum)
* [apt](https://supermarket.chef.io/cookbooks/apt)

Tested on Ubuntu 12.04, Debian 7.1 and SL6.5. Will not work on Debian earlier than 7.0, Ubuntu older than 12.04 or rhel based distros older than 6.0.

Attributes
----------
* `default['gluster-client']['ubuntu_ppa'] = "ppa:gluster/glusterfs-3.6"`
* `default['gluster-client']['rhel_packages'] = ['glusterfs-fuse', 'glusterfs', 'glusterfs-libs', 'glusterfs-api']`
* `default['gluster-client']['rhel_repo'] = "http://download.gluster.org/pub/gluster/glusterfs/3.6/LATEST/CentOS/glusterfs-epel.repo"`
* `default['gluster-client']['debian_packages'] = ['glusterfs-client', 'glusterfs-common']`
* `default['gluster-client']['debian_repo'] = "http://download.gluster.org/pub/gluster/glusterfs/3.6/3.6.2/Debian/wheezy/apt"`
* `default['gluster-client']['debian_key'] = "http://download.gluster.org/pub/gluster/glusterfs/3.6/3.6.2/Debian/wheezy/pubkey.gpg"`

Usage
-----
Just include `gluster-client` in your node's `run_list`:

```json
{
  "name":"my_node",
  "run_list": [
    "recipe[gluster-client]"
  ]
}
```

and specify the mounts in your role file:

```json
    "mounts" => {
        "gluster" => {
            "/mnt/distributed-volume"=> "brick1.com,brick2.com,brick3.com,brick4.com:/volume-name"
        }
```

Contributing
------------
TODO: (optional) If this is a public cookbook, detail the process for contributing. If this is a private cookbook, remove this section.

e.g.
1. Fork the repository on Github
2. Create a named feature branch (like `add_component_x`)
3. Write your change
4. Write tests for your change (if applicable)
5. Run the tests, ensuring they all pass
6. Submit a Pull Request using Github

License and Authors
-------------------
Authors<EMAIL_ADDRESS>

repository: Indatus/gluster-client

repo_name: Indatus/gluster-client


text:
---
title: LessCSS
image_width: 200
image_height: 90
image: /assets/images/lesscss.png
url: http://lesscss.org/
source: https://github.com/less/less.js
tags:
  - apps
  - css
  - lesscss
description: >
  LessCSS is a language designed
  to build advanced CSS3
  visualization.

---
CSS3 has many options but
it has a low degree of re-usability.
LessCSS is a language designed
to replace/complement CSS3.

LessCSS is in fact a Javascript program.
It can run in any browser,
even in any server, if it is required.
It allows to use LessCSS directly
as native stylesheets.
LessCSS allows to define
functions, variables,
and reuse parts.
It has also connectors to be integrated
into NodeJS servers, or
other technologies like GruntJS or Ruby.

LessCSS is compatible with CSS3,
in other words, any CSS3 code is a LessCSS
valid code.
It will makes easy to use to any designer.

```less
@base: #f938ab;

.box-shadow(@style, @c) when (iscolor(@c)) {
  box-shadow:         @style @c;
  -webkit-box-shadow: @style @c;
  -moz-box-shadow:    @style @c;
}
.box-shadow(@style, @alpha: 50%) when (isnumber(@alpha)) {
  .box-shadow(@style, rgba(0, 0, 0, @alpha));
}
.box {
  color: saturate(@base, 5%);
  border-color: lighten(@base, 30%);
  div { .box-shadow(0 0 5px, 30%) }
}
```


text:
Please visit [Pyrustic](https://github.com/pyrustic/pyrustic#readme).

    The Pyrustic software suite with the cyberpunk theme

repository: pyrustic/hubway

repo_name: pyrustic/hubway


text:
---
layout: default
---

# 1994-02-14 - Re: Strategies for getting encryption in widespread use QUICKLY

## Header Data

From: "Pat Farrell"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 670c27976b02a2d8188fd0e7fa2530dc8f1701df98fef3c23f98f7a13cb7855e

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-02-14 10:21:21 UTC

Raw Date: Mon, 14 Feb 94 02:21:21 PST

## Raw message

```
{% raw  %}From: "Pat Farrell"<EMAIL_ADDRESS>Date: Mon, 14 Feb 94 02:21:21 PST
To<EMAIL_ADDRESS>Subject: Re: Strategies for getting encryption in widespread use QUICKLY
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

In message Sun, 13 Feb 94 09:50:59 +0200,
  Johan Helsingius<EMAIL_ADDRESS>writes:

> As far as I know, there are *several* PD Windows SLIP packages.

Yes. there are.

I am motivated from the other end. I can get the client code I need, I can't
get "widespead use" at the server end. For example, GMU, which
nominally provides Internet access to all of its students, refuses to
support SLIP or PPP on any of its servers. No reason, just policy.

I gave up on GMU's services and pay Netcom to give me access. They charge
$2.00 per hour for SLIP/PPP, but all the async access I want is flat rate.

Until the politics and economics change, I believe widespread use will
require a non-IP approach. Sure IP would be better, so would ISDN.

But Eudora and NUpop work fine, over straight async. they just miss the
encryption hook.

I have no interest in debating the value of IP. I am looking for help in
building a non-IP client that can enable encrypted mail to the
great mass of computer owners who are clueless about technology.

Pat

Pat Farrell      Grad Student<EMAIL_ADDRESS>Department of Computer Science    George Mason University, Fairfax, VA
Public key availble via finger          #include <standard.disclaimer>

{% endraw %}
```

## Thread

+ Return to [February 1994](/archive/1994/02)

+ Return to "["Pat Farrell" <pfarrell@netcom.com>](/authors/pat_farrell_pfarrell_at_netcom_com_)"

+ 1994-02-14 (Mon, 14 Feb 94 02:21:21 PST) - Re: Strategies for getting encryption in widespread use QUICKLY - _"Pat Farrell"<EMAIL_ADDRESS>


text:
---
title: WEBP Filter
---

The WebP filter compresses image data using [libwebp](https://developers.google.com/speed/webp/docs/api#headers_and_libraries). The current input formats supported are `RGB`, `RGBA`, `BGR`, and `BGRA`. The colorspace format can be configured for this filter by setting the `TILEDB_WEBP_INPUT_FORMAT` filter option. Tile-based compression is determined by dimension extents. Extents equal to dimension bounds will compress the image in one pass.

For attributes, the WebP filter supports only the uint8_t data type.
Dimension data types can be any two matching integral types, such as `{uint32_t, uint32_t}` or `{int64_t, int64_t}` for example.

```
# Data from 2x3 pixel image
input = [[255,62,83, 149,43,67, 138,43,67]
         [255,62,83, 149,43,67, 138,43,67]]
# Ingest and read with lossless compression
output = [[255,62,83, 149,43,67, 138,43,67]
          [255,62,83, 149,43,67, 138,43,67]]
# Ingest and read with lossy compression
output = [[251,60,84, 148,51,61, 142,42,64]
          [252,63,85, 150,46,67, 139,44,68]]
```

The figure below from WebP API documentation may help to understand the format of data passed to and read from the WebP filter.

![](../figures/bgra_layout.png) \
[Photo](https://developers.google.com/static/speed/webp/images/image_layout.png) by [Google](https://developers.google.com/speed/webp/docs/api) licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)

Using the figure above from [WebP API documentation](https://developers.google.com/speed/webp/docs/api), `height` should correspond with dimension 0 upper bound, while `stride` corresponds with dimension 1 upper bound.
The pixel `width` of the image is internally calculated based on colorspace format and tile extents.

Tile extents are used to configure tile-based compression. We should note that the [maximum WebP image size](https://developers.google.com/speed/webp/faq#what_is_the_maximum_size_a_webp_image_can_be) is 16383x16383.
Because of this, our extents can not exceed `16383` for dimension 0, and `16383 * pixel_depth` for dimension 1.
`pixel_depth` is defined by our colorspace format selection. `RGB` and `BGR` images have a depth of 3, while `RGBA` and `BGRA` have a depth of 4 for the additional alpha value provided for each pixel.

# Filter Enum Value

The filter enum value for the WEBP filter is `17` (TILEDB_FILTER_WEBP enum).

# Input and Output Layout

Input is a single array of colorspace values in RGB, BGR, RGBA, or BGRA format. For RGB format we would expect the first
pixel to store R, G, B values at `input[0]`, `input[1]`, and `input[2]` respectively, followed by the remaining pixels
in the image. Ingesting a 10x10 image would expect 300 total input values for 10 rows of 30 colorspace values per-row.

Output is organized the same as input. If we compress an image with lossless enabled, all outputs match inputs exactly.
If we instead use lossy compression with a quality of 0, output colorspace values will vary due to data lost during
lossy WebP compression but the organization of the data remains the same.

repository: TileDB-Inc/TileDB

branch_name: refs/heads/dev

repo_name: TileDB-Inc/TileDB


text:
# CSS Interview Questions

> Good answers to questions about HTML are on the website for [W3Schools](https://www.w3schools.com/).

What is CSS selector specificity and how does it work?

> I tend not to write CSS selectors much more complicated than `.className p` or `#id a`.    I would have to look up how more complicated selectors work (and would probably replace them with simpler selectors that were easier to understand.

What's the difference between "resetting" and "normalizing" CSS? Which would you choose, and why?

Describe floats and how they work.

> Floats position elements relatively on a page, aligning them to the left or the right with respect to surrounding elements. Text will flow around in-line floats.  Floats can be cleared (e.g., before a heading) with the CSS `clear: both` attribute.

Describe z-index and how stacking context is formed.

> The z-index determines what content is on top when several elements on a page overlap.

Describe BFC (Block Formatting Context) and how it works.

> The BFC handles the placement of elements on a page.  It takes into account things like absolute vs. relative positioning, floats, in-line blocks, table elements, and overflows.

What are the various clearing techniques and which is appropriate for what context?

> `style="clear: both;"` works for floats.  `overflow: hidden` works for overflowing content.

Explain CSS sprites, and how you would implement them on a page or site.

> I don't know what these are.

How would you approach fixing browser-specific styling issues?

> Either I use browser-specific CSS attributes or I have an onload function change the classes of elements to match the user's browser.

How do you serve your pages for feature-constrained browsers? What techniques/processes do you use?

> This is not something I have worried about.  My primary web-based application, the Formula Forge add-in for Microsoft Excel, requires browsers capable of handling Excel for the Web.

What are the different ways to visually hide content (and make it available only for screen readers)?

> `display: none` hides content without taking up any space.  `visibility: hidden` hides content, but reserves space for it.  `width: 0; height: 0; overflow: hidden` hides content in a zero-size box.

Have you ever used a grid system, and if so, what do you prefer?

Have you used or implemented media queries or mobile specific layouts/CSS?

> No

Are you familiar with styling SVG?

> Yes.  My Formula Forge application uses SVG to draw diagrams with labels in various colors.

Can you give an example of an @media property other than screen?

> "@media" print

What are some of the "gotchas" for writing efficient CSS?

> I don't know.  I don't write CSS that's so complicated I have to worry about efficiency.

What are the advantages/disadvantages of using CSS preprocessors?

> CSS extensions like Less and Sass allow you to split CSS into separate files and to use variables.  However, they require translation into CSS and they introduce another level of complexity and their use may require maintenance as their definitions evolve.

Describe what you like and dislike about the CSS preprocessors you have used.

> I liked the ability to use variables, but found it more difficult to debug the CSS generated by the preprocessor.

How would you implement a web design comp that uses non-standard fonts?

> What's a "web design comp"?  I've had experience with non-standard fonts in TeX and Metafont, would look to them for guidance on how to use nonstandard fonts in a web page.

Explain how a browser determines what elements match a CSS selector.

Describe pseudo-elements and discuss what they are used for.

> I've used :before and :after to draw triangles in menu items to indicate that they lead to submenus.

Explain your understanding of the box model and how you would tell the browser in CSS to render your layout in different box models.

> My web pages make heavy use of the box model to set the sizes, borders, background colors, margins, padding, and positions of HTML elements.

What does `*{ box-sizing: border-box; }` do? What are its advantages?

> I need to look this one up.

What is the CSS display property and can you give a few examples of its use?

> The CSS display property tells browsers how to display a block.  Some possibilities are inline (via inline), visible (via block), and invisible (via none).

What's the difference between inline and inline-block?

What's the difference between a relative, fixed, absolute and statically positioned element?

> Relative elements flow into the page.  Absolute elements are displayed at fixed locations, indicated by their top and left offsets relative to their enclosing elements.  Would have to look up how fixed and static positioning differ from absolute positioning.

What existing CSS frameworks have you used locally, or in production? How would you change/improve them?

> Just those that come with Angular.  I prefer working with vanilla flavored CSS, though I would appreciate being able to split my CSS into separate files.

Have you played around with the new CSS Flexbox or Grid specs?

> Yes, but I find that floats work better for me.

Can you explain the difference between coding a web site to be responsive versus using a mobile-first strategy?

> No

How is responsive design different from adaptive design?

> Responsive design customizes a page's appearance to the device on which it is viewed.  I'm not familiar with adaptive design as a separate technology.

Have you ever worked with retina graphics? If so, when and what techniques did you use?

> No

Is there any reason you'd want to use translate() instead of absolute positioning, or vice-versa? And why?

repository: sjgarland/resilient-coders

path: /Interview Questions/CSS.md

repo_name: sjgarland/resilient-coders


text:
# Celeste-Movement

The main mechanics of Celeste that I created in Godot Engine

The sprites I used was made by Nate Kling for Mix and Jam youtube channel.

Here is the video that Mix and Jam creates the Celeste movement in Unity: https://www.youtube.com/watch?v=STyY26a_dPY

Thanks for your attention, have a nice day!

repository: Enriik/Celeste-Movement

repo_name: Enriik/Celeste-Movement


text:
# so-tetris-python
Tetris Python OOPS and DDD Demo
  ```
    python3 so-tetris-python/so_tetris_mania.py >> logs.txt 2>&1
```
- Quick attempt to demo OOPS and DDD in python
    -  Initial rough code is present in so-tetris-python/so-dev/so_tetris_dev_full.py
    -  Later refactored the code as per OOPS recommendations.
    -  Many items are still pending for calling it full-fledged game and can be taken up as time permits.

- Dependencies : pygame
- Dev Env : VSCode on macOS Big Sur

- DDD Description
    -  All the configurations in config directory
        - board_config
        - display_config
    -  Game app is divided into Display and Board
        - Display is for managing pygame aspects - Display of screen elements and capturing/handling of events
        - Board is the Gameplay code encapsulating the -
            - logical board,
            - minos(shapes) - their movement,
            - metadata - game score etc.

    -  Display code is in display dir
        - so_display - all the screen elements and pygame lib management
        - so_event_listener - receives all the events on screen and redirects activities to appropriate modules
        - so_display_helper - isolated utility methods for display module

    -  Board logic is in board dir
        - so_board - DDD logical model for the Tetris board hosting all the cells and their properties
        - so_mino - DDD logical model for tetris minos.
            i. minos are the shapes spawned at the top which then move down till they are stopped by inactive cells.
            ii. This has methods for movement - LRB, rotation etc.
        - so_mino_helper - Hosts static utility functions for rotation and spawning of new minos(shapes)
        - so_metadata - stores the game data for score state etc.

    -  Lauch of the app is from this file -
    ```
        python3 so-tetris-python/so_tetris_mania.py >> logs.txt 2>&1
    ```
    -  Logger used - can configure to direct logs to specific file as per deployment.

    -  All the pending TODOs are captured in so_tetris_mania.py
#
# Screenshot 1

![Sample screenshot](https://github.com/soaprasri/so-tetris-python/blob/main/images/screenshot.png)

repository: soaprasri/so-tetris-python

repo_name: soaprasri/so-tetris-python


text:
# screepsctl

Need some kind of central intelligence

Emperor -> Duke -> Baron
Shard   -> Room -> Spawn

## Initial plan

* Harvester
	* Energy
		* Feeder (give to spawn/extensions/storage)
			* Need smarts to go to closest source with open spot (or with spot open soonest?)
	* Minerals
		* This is later, need levels first
* Upgrader
	* Take from spawn, use to upgrade controller
* Builder
	* Primary duty: fix things degraded past some amount, tbd
	* Secondary duty: build new items

* Weighted strategy
	* Need to produce harvesters during peaceful times `(number of harvesters) / (number of resource spots)`
	* Need to produce builders `(number of builders) / (number of buildings to build/maintain)`

## Other ideas

* Build roads between well travelled places
	* Once there are X harvesters, build road from storage to energy source & minerals

* metrics
	* rolling average, `x` resources per tick for various resources
	* rolling average 1 `creep type` every `x` seconds

* use a different logger that i can change the level of at runtime
	* (ie by reading a memory value i can set from the command line)

* can i write to the network? so that i could get logs remotely?

* require non-spawn storage containers to exist before taking energy from anything else
	* taking energy from spawn can potentially starve the colony until all creeps die and it can restart

### Responding to threats

Low level attacks can probably be handled by walls/ramparts and turrets
If a significant or extended attack happens, need to adjust production quickly to respond, assign more creeps to fixing or constructing

repository: bmhenry/screepsctl

repo_name: bmhenry/screepsctl


text:
CKCalendar
==========

CKCalendar is a sleek, easily customizable calendar control for iOS. Simply add the header, implementation, and resource files to your project and link against it's framework dependencies: QuartzCore and CoreGraphics.

![CKCalendar screenshot](http://cloud.github.com/downloads/jaykz52/CKCalendar/CKCalendar.png)

The default calendar design is courtesy of [John Anderson](http://twitter.com/jrileyd). Thanks John!

## Interacting with CKCalendar
CKCalendar provides delegate callbacks to interact with the calendar in the way you would expect:

``` objc
- (void)someMethod {
  CKCalendarView *calendar = [[CKCalendarView alloc] init];
  [self.view addSubview:calendar];
  calendar.delegate = self;
}

// snip...

- (void)calendar:(CKCalendarView *)calendar didSelectDate:(NSDate *)date {
  // show the user the date they selected
  self.dateLabel.text = [date description];
}

```

## Back-filling previous/next month
You can enable fully filling the remaining calendar space before and after the current month. The styling of the non-current month cells can be customized.
``` objc
calendarView.shouldFillCalendar = YES;
calendarView.nonCurrentMonthDateTextColor = [UIColor redColor];
```

## Customizing
The calendar was written to be easily styled so that you can make it feel seamless in your app. You can customize the fonts, text colors, and background colors of nearly every element. You can also configure what day of the week the calendar should start on. The calendar allows you to set optional minimum and/or maximum selectable dates (which are also stylable). If you still have a feature not yet met, add it! The code is readable and quite extendable at this point. Enjoy!

## License (MIT)
Copyright (c) 2012 Jason Kozemczak

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

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

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

repository: ChronicStim/CKCalendar

repo_name: ChronicStim/CKCalendar


text:
# Spacemacs

## Installation

```
brew tap d12frosted/emacs-plus
brew install emacs-plus
git clone https://github.com/syl20bnr/spacemacs ~/.emacs.d
brew tap caskroom/fonts && brew cask install font-source-code-pro
```

1. Open Emacs
1. Choose default editing style (evil)
1. Choose standard distribution
1. Choose full-featured completion framework (helm)
1. Emacs will automatically download and install packages
1. Open .spacemacs file (SPC f e d)
1. Make sure these lines are present/uncommented under dotspacemacs-configuration-layers:

       clojure
       helm
       auto-completion
       better-defaults
       emacs-lisp
       git
       html
       javascript
       markdown
       org
       (shell :variables
              shell-default-height 30
              shell-default-position 'bottom)
       syntax-checking
       version-control
1. The javascript layer expects tern.js to be installed, so to avoid seeing errors on startup you should run `npm install -g tern`.

## Switch to dev branch

      cd ~/.emacs.d
      git checkout develop

To update on develop branch

1. Select `[Update Packages]` on start screen
1. Close Emacs
1. `cd ~/.emacs.d; git pull --rebase`

Sources:

- [Beginner's tutorial](https://github.com/syl20bnr/spacemacs/blob/master/doc/BEGINNERS_TUTORIAL.org)
- [Use homebrew to install emacs](https://github.com/syl20bnr/spacemacs#macos)
- [Use homebrew to install source code pro font](https://github.com/adobe-fonts/source-code-pro#font-installation-instructions)
- [How to switch to dev branch?](https://www.reddit.com/r/spacemacs/comments/79xkfa/how_do_i_switch_to_the_dev_branch/)
- [Update on develop branch](https://github.com/syl20bnr/spacemacs#on-develop-branch)

repository: feihong/cheatsheets

repo_name: feihong/cheatsheets


text:
# go-score

Go game scorer. Very much a work in progress.

    go build
    ./go-score game.sgf

# Resources

- [Eidogo: Quick play online](http://eidogo.com/)
- [SGF spec](http://www.red-bean.com/sgf/properties.html)
- [Terminating and Scoring Go](http://jpolitz.github.io/blog/2012/12/25/go-termination.html)

repository: bgreenlee/go-score

repo_name: bgreenlee/go-score


text:
---

title: "Thermodynamic Property and Fluid Modeling with Modern Programming Language Constructs"
journal: "Modelica'2019 - Proceedings of the 13th International Modelica Conference"
authors:
- Martin Otter
- Hilding Elmqvist
- Dirk Zimmer
- Christopher Laughman
year: "2019"
pages:
doi: 10.3384/ecp19157589
packages:
  ModiaMedia.jl: https://github.com/ModiaSim/ModiaMedia.jl
---

Modelica is used extensively to model thermo-fluid pipe networks.
Experience shows that Modelica models in this domain have limitations
due to missing functional expressiveness of the Modelica language.
In this paper, a prototype is described that demonstrates how thermodynamic
property and thermo-fluid pipe component modeling could be considerably
enhanced via modern language constructs available in Julia.
This prototype is based on the Modia modelling and simulation prototype and
relies on features of the Julia programming language.
It utilizes some key ideas of Modelica.Media, and part of
Modelica.Media was semi-automatically translated to Julia.


text:
![](https://github.com/osrf/free_fleet/workflows/build/badge.svg)

This repository is under active development. Things will be quite unstable
for a while. Please open an issue ticket on this repo if you have problems.
Cheers.

# Overview
Welcome to `free_fleet`, an open-source robot fleet management system.
Sometimes it is called the "Fun Free Fleet For Friends" (F5).

# Requirements

ROS 1 Melodic and ROS 2 Eloquent need to be installed, since the ROS 1 client
uses DDS implementations packaged as part of the ROS 2 project.

The build scripts assume that ROS 2 Eloquent is installed to the canonical
location in `/opt/ros/eloquent`

# Documentation and notes

* [Generating the CycloneDDS message types](docs/msgs.md)

* [Building the ROS 1 Client](docs/clients.md)

* [Running tests on the ROS 1 Client](docs/clients_test.md)


text:
# ColorWave

Creates a color-cycling wave of characters in the terminal. All-in-all pretty useless.

## Installation

Add this line to your application's Gemfile:
```ruby
gem 'color_wave'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install color_wave

## Usage

You can run it from the command line with or without some options:

    $ color_wave --lines 20 --cycles 3 --speed 10.0

The above values are the defaults.
##### Options
* `--lines` - the height of the wave in terminal lines
* `--cycles` - how many cycles of the wave will be drawn
* `--speed` - used as the divisor of the delay time between drawing loops; use higher values for faster redrawing
* `--help` - show usage information

You can use it in Ruby too:
```ruby
require 'color_wave'

ColorWave.new(lines: 10, cycles: 2, speed: 1, colors: %w( ff0000 00ff00 0000ff ), chars: %w( _ / ^ \ )).run
```

The `speed` option is used as the divisor to a `BASE_SLEEP_TIME` constant so higher speeds will redraw the wave more quickly. The `colors` and `chars` options specify the colors and characters to be cycled through when drawing the wave.

`Ctrl-C` will stop it once it's running.

## Contributing

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

## License

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


text:
+++
# About/Biography widget.
widget = "about"
active = true
date = 2016-04-20T00:00:00

# Order that this section will appear in.
weight = 5

# List your academic interests.
[interests]
  interests = [
    "Artificial Intelligence",
    "Continual AI",
    "Autonomous Vehicles"
  ]

# List your qualifications (such as academic degrees).
[[education.courses]]
  course = "MEng in Robotics"
  institution = "Université Pierre et Marie Curie - Sorbonne Université"
  year = 2018

[[education.courses]]
  course = "BS in Mechanical Engineering"
  institution = "Université Pierre et Marie Curie - Sorbonne Université"
  year = 2016

+++

# Biography

Adrien Bennetot is a PhD Student in artificial intelligence. His research interests include symbolic learning, explainable AI and scene understanding.

repository: AdriBento/academic-website

repo_name: AdriBento/academic-website


text:
# noter

Basic CLI organizer for https://github.com/chyyran/notes.

## Usage

### Create a notes folder in the current directory.

```
$ noter course EAS103 "Premodern East Asia"
```

### Create a new note for the subject (relative to the root of all the notes folders)

#### Create an untitled note for a subject
```
$ noter new EAS330
```

#### Create a note with a title
```
$ noter new CSC263 "Binomial Heaps"
```

repository: chyyran/noter

repo_name: chyyran/noter


text:
### Barclamp APIs

Barclamps are the core modulization for OpenCrowbar.  For that reason, the API for barclamps is more limited because changes to barclamps can cause breaking changes to the framework.

#### Barclamp List

**Input:**

| Verb | URL | Options | Returns | Comments |
|:------|:-----------------------|--------|--------|:----------------|
| GET | /crowbar/v2/barclamps | none | All barclamps | - |

**Output:**

#### Barclamp Catalog

Provides the list of supported resources for the API

| Verb | URL | Options | Returns | Comments |
|:------|:-----------------------|--------|--------|:----------------|
| GET | /[:barclamp]/v2/catalog | none | Actions List | - |

#### Barclamp Template

**Input:**

| Verb | URL | Options | Returns | Comments |
|:------|:-----------------------|--------|--------|:----------------|
| GET | /[:barclamp]/v2/template | none | Redirects to Template Instance | - |

This will redirect to the Instance used for the template.

#### Not Supported

Barclamp API does not support create, update and delete operations.

#### API v1 temporary dumping ground

 scope 'crowbar' do
    version = "1.0"

    get    ":controller/#{version}/help", :action => 'help', :as => :help_barclamp
    get    ":controller/#{version}/proposals/nodes", :action=>'nodes', :as => :barclamp_nodes
    put    ":controller/#{version}/proposals", :action => 'proposal_create', :as => :create_proposal_barclamp
    get    ":controller/#{version}/proposals", :action => 'proposals', :as => :proposals_barclamp
    post   ":controller/#{version}/proposals/commit/:id", :action => 'proposal_commit', :as => :commit_proposal_barclamp
    delete ":controller/#{version}/proposals/dequeue/:id", :action => 'proposal_dequeue', :as => :dequeue_barclamp
    delete ":controller/#{version}/proposals/:id", :action => 'proposal_delete', :as => :delete_proposal_barclamp
    post   ":controller/#{version}/proposals/:id", :action => 'proposal_update', :as => :update_proposal_barclamp
    get    ":controller/#{version}/proposals/:id", :action => 'proposal_show', :as => :proposal_barclamp
    get    ":controller/#{version}/elements", :action => 'elements'
    get    ":controller/#{version}/elements/:id", :action => 'element_info'
    match  ":controller/#{version}/transition/:id", :action => 'transition', :via => [:get, :post]
    get    ":controller/#{version}", :action => 'index', :as => :index_barclamp
    delete ":controller/#{version}/:id", :action => 'delete', :as => :delete_barclamp
    get    ":controller/#{version}/:id", :action => 'show', :as => :show_barclamp
    get    ":controller", :action => 'versions', :as => :versions_barclamp
    post   ":controller/#{version}/:action/:id", :as => :action_barclamp
    get    '/', :controller => 'barclamp', :action => 'barclamp_index', :as => :barclamp_index_barclamp
    get    "modules/#{version}", :controller => 'barclamp', :action => 'modules', :as => :barclamp_modules

    # Generic fall through routes
    get    ":barclamp/#{version}/help", :action => 'help', :controller => 'barclamp'
    get    ":barclamp/#{version}/proposals/nodes", :controller => "barclamp", :action=>'nodes'
    put    ":barclamp/#{version}/proposals", :action => 'proposal_create', :controller => 'barclamp'
    get    ":barclamp/#{version}/proposals", :action => 'proposals', :controller => 'barclamp'
    post   ":barclamp/#{version}/proposals/commit/:id", :action => 'proposal_commit', :controller => 'barclamp'
    get    ":barclamp/#{version}/proposals/status(/:id)(.:format)", :controller => 'barclamp', :action => 'proposal_status', :controller => 'barclamp'
    delete ":barclamp/#{version}/proposals/:id", :action => 'proposal_delete', :controller => 'barclamp'
    post   ":barclamp/#{version}/proposals/:id", :action => 'proposal_update', :controller => 'barclamp'
    get    ":barclamp/#{version}/proposals/:id", :action => 'proposal_show', :controller => 'barclamp'
    get    ":barclamp/#{version}/elements", :action => 'elements', :controller => 'barclamp'
    get    ":barclamp/#{version}/elements/:id", :action => 'element_info', :controller => 'barclamp'
    match  ":barclamp/#{version}/transition/:id", :action => 'transition', :via => [:get, :post], :controller => 'barclamp'
    get    ":barclamp/#{version}", :action => 'index', :controller => 'barclamp'
    get    ":barclamp/#{version}/status", :action => 'status', :controller => 'barclamp'
    delete ":barclamp/#{version}/:id", :action => 'delete', :controller => 'barclamp'
    get    ":barclamp/#{version}/:id", :action => 'show', :controller => 'barclamp'
    get    ":barclamp", :action => 'versions', :controller => 'barclamp'
    post   ":barclamp/#{version}/:action/:id", :controller => 'barclamp'

    match "/", :controller => 'barclamp', :action => 'barclamp_index', :via => :get, :as => :barclamp_index_barclamp

  end

repository: mikeyp-dell/core

repo_name: mikeyp-dell/core


text:
---
layout: post
title: O Christmas Tree
date: 2006-12-07 15:06
author: admin
comments: true
categories: [Life]
---
So we put up the Christmas tree at Holly's last weekend.  We bought some of those new LED lights, a few ornaments and some silver bids.  We're pretty happy with the tree :)

It was nice to have a start to the Christmas Season like this.  Holly baked cookies and made home made cocoa and we trimmed the tree.  It was an all around good time.

Her cat Max didn't quite know what to make of the tree.  When we hauled it out of the box he got so stressed out that he threw up (he's a nervous creature).  Now it seems like he feels right at home with it though.  There is some evidence of him trying to climbe it and he enjoys sleeping under it.

Picutres:

Tree in the dark:

Tree with the lights on:

Tree after you've had too much to drink:


text:
---
version: v0.36.4
category: Development
title: 'Build Instructions Linux'
source_url: 'https://github.com/atom/electron/blob/master/docs/development/build-instructions-linux.md'
---

# Build Instructions (Linux)

Follow the guidelines below for building Electron on Linux.

## Prerequisites

* Python 2.7.x. Some distributions like CentOS still use Python 2.6.x
  so you may need to check your Python version with `python -V`.
* Node.js v0.12.x. There are various ways to install Node. You can download
  source code from [Node.js](http://nodejs.org) and compile from source.
  Doing so permits installing Node on your own home directory as a standard user.
  Or try repositories such as [NodeSource](https://nodesource.com/blog/nodejs-v012-iojs-and-the-nodesource-linux-repositories).
* Clang 3.4 or later.
* Development headers of GTK+ and libnotify.

On Ubuntu, install the following libraries:

```bash
$ sudo apt-get install build-essential clang libdbus-1-dev libgtk2.0-dev \
                       libnotify-dev libgnome-keyring-dev libgconf2-dev \
                       libasound2-dev libcap-dev libcups2-dev libxtst-dev \
                       libxss1 libnss3-dev gcc-multilib g++-multilib
```

On Fedora, install the following libraries:

```bash
$ sudo yum install clang dbus-devel gtk2-devel libnotify-devel libgnome-keyring-devel \
                   xorg-x11-server-utils libcap-devel cups-devel libXtst-devel \
                   alsa-lib-devel libXrandr-devel GConf2-devel nss-devel
```

Other distributions may offer similar packages for installation via package
managers such as pacman. Or one can compile from source code.

## If You Use Virtual Machines For Building

If you plan to build Electron on a virtual machine you will need a fixed-size
device container of at least 25 gigabytes in size.

## Getting the Code

```bash
$ git clone https://github.com/atom/electron.git
```

## Bootstrapping

The bootstrap script will download all necessary build dependencies and create
the build project files. You must have Python 2.7.x for the script to succeed.
Downloading certain files can take a long time. Notice that we are using
`ninja` to build Electron so there is no `Makefile` generated.

```bash
$ cd electron
$ ./script/bootstrap.py -v
```

### Cross compilation

If you want to build for an `arm` target you should also install the following
dependencies:

```bash
$ sudo apt-get install libc6-dev-armhf-cross linux-libc-dev-armhf-cross \
                       g++-arm-linux-gnueabihf
```

And to cross compile for `arm` or `ia32` targets, you should pass the
`--target_arch` parameter to the `bootstrap.py` script:

```bash
$ ./script/bootstrap.py -v --target_arch=arm
```

## Building

If you would like to build both `Release` and `Debug` targets:

```bash
$ ./script/build.py
```

This script will cause a very large Electron executable to be placed in
the directory `out/R`. The file size is in excess of 1.3 gigabytes. This
happens because the Release target binary contains debugging symbols.
To reduce the file size, run the `create-dist.py` script:

```bash
$ ./script/create-dist.py
```

This will put a working distribution with much smaller file sizes in
the `dist` directory. After running the create-dist.py script, you
may want to remove the 1.3+ gigabyte binary which is still in `out/R`.

You can also build the `Debug` target only:

```bash
$ ./script/build.py -c D
```

After building is done, you can find the `electron` debug binary under `out/D`.

## Cleaning

To clean the build files:

```bash
$ ./script/clean.py
```

## Troubleshooting

Make sure you have installed all of the build dependencies.

### Error While Loading Shared Libraries: libtinfo.so.5

Prebulit `clang` will try to link to `libtinfo.so.5`. Depending on the host
architecture, symlink to appropriate `libncurses`:

```bash
$ sudo ln -s /usr/lib/libncurses.so.5 /usr/lib/libtinfo.so.5
```

## Tests

Test your changes conform to the project coding style using:

```bash
$ ./script/cpplint.py
```

Test functionality using:

```bash
$ ./script/test.py
```

branch_name: refs/heads/gh-pages


text:
# hydropump
A chrome extension that reminds you to drink water on a regular basis

#### How to install
- clone the repository to your device
- enable developer mode in your chrome browser
- click on 'Load unpacked extension...' button
- browse to the clone folder and click open

#### How to use
- select the desired interval in the options menu, check enable and save
- enable or disable the service from options or from the popup menu

repository: shrsujan/hydropump

repo_name: shrsujan/hydropump


text:
---
title: "R Exploratory Data Analysis"
author: "Nathan Garrett"
date: "2023-08-21T18:03:01Z"
tags: [Exploratory Data Analysis]
link: "https://bookdown.org/profgarrett/course_r_eda/"
length_weight: "2.3%"
pinned: false
---

R Exploratory Data Analysis [...] This site is for the ACCT 426 and BUDA 451 classes in Fall 2023.
It has been created by Nathan Garrett<EMAIL_ADDRESS>...

gha_language: R


text:
---
layout: component.njk
title: Tree
tags: api
component: vscode-tree
---

# Tree

<details>
<summary>Custom types</summary>

```typescript
type ListenedKey = 'ArrowDown' | 'ArrowUp' | 'Enter' | 'Escape' | ' ';

type IconType = 'themeicon' | 'image';

type IconVariant = 'branch' | 'leaf' | 'open';

export interface TreeItemIconConfig {
  branch?: string;
  open?: string;
  leaf?: string;
}

/** Action icon configuration. */
export interface TreeItemAction {
  /** A unique name that identifies the clicked action item. */
  actionId: string;
  /** A Codicon name. */
  icon: string;
  /** Text description of the action. */
  tooltip?: string;
}

/**
 * The decoration is additional content on the right side of the tree item. It can be a short text,
 * a counter, or a small, filled circle. A color can be defined for the different states. If
 * multiple states are applied to the item, the color with higher precedence will be used. The color
 * precedence from higher to lower is selected, focused, hover, normal. Colors will not be applied
 * to the counter badge.
 */
export interface TreeItemDecoration {
  /** Text content of the decoration. If the appearance is `filled-circle`, it will be ignored. */
  content?: string;
  /** Appearance of the decoration. */
  appearance?: 'text' | 'counter-badge' | 'filled-circle';
  /**
   * When is decoration visible?
   * - `active`: visible when the tree item is focused, selected or hovered
   * - `normal`: visible when there is not any interaction on the tree item
   * - `always`: always visible
   */
  visibleWhen?: 'active' | 'normal' | 'always';
  /** A valid CSS property value to define a default color. */
  color?: string;
  /** A valid CSS property value to define the color for the mouse over state. */
  hoverColor?: string;
  /** A valid CSS property value to define the color for the focused state. */
  focusedColor?: string;
  /** A valid CSS property value to define the color for the selected state. */
  selectedColor?: string;
}

export interface TreeItem {
  label: string;
  description?: string;
  subItems?: TreeItem[];
  actions?: TreeItemAction[];
  open?: boolean;
  selected?: boolean;
  focused?: boolean;
  hasSelectedItem?: boolean;
  hasFocusedItem?: boolean;
  icons?: TreeItemIconConfig | boolean;
  iconUrls?: TreeItemIconConfig;
  value?: string;
  path?: number[];
  decorations?: TreeItemDecoration[];
}

type ItemType = 'branch' | 'leaf';

/** Event payload of the `vsc-select` event. */
interface SelectEventDetail {
  /** Icon configuration of the clicked item */
  icons: TreeItemIconConfig | undefined | boolean;
  /** Is item type branch or leaf. */
  itemType: ItemType;
  /** The visible label of the item. */
  label: string;
  /** The value associated to the item. */
  value: string;
  /** Is the item opened if it's a branch. */
  open: boolean;
  /** Path represents the item place in the tree. For example 1/2/3 means:
   * `data[1].subItems[2].subItems[3]` */
  path: string; // ex.: 0/0/1
}
```

</details>

repository: bendera/vscode-webview-elements

repo_name: bendera/vscode-webview-elements


text:
# Transport Layer Security (TLS) Sample

This sample demonstrates a client and silo which communicate over a channel secured by Transport Layer Security (TLS).

## Running the sample

For the purpose of the sample, we will generate and use a self-signed certificate.

***NOTE:*** Ensure that security best practices are followed when deploying your application to a production environment.

A self-signed certificate can be generated & installed using PowerShell:

``` powershell
$cert = New-SelfSignedCertificate -CertStoreLocation Cert:\LocalMachine\My -DnsName "fakedomain.faketld"
```

Now that the certificate configured in the sample is installed, run the client and silo:

Start the silo using the following command:

``` powershell
dotnet run --project src\SiloHost
```

Start the client in a different command window using the following command:

``` powershell
dotnet run --project src\OrleansClient\
```

Once you have successfully run the sample, remove the self-signed certificate which was generated above:

``` powershell
Remove-Item "Cert:\LocalMachine\My\$($cert.ThumbPrint)"
```

repository: ReubenBond/orleans

gha_language: C#

repo_name: ReubenBond/orleans


text:
---
layout: default
---

# 1993-09-12 - Re: nada against the gubbamess...

## Header Data

From<EMAIL_ADDRESS>(Doug Merritt)

To<EMAIL_ADDRESS>Message Hash: 66a70773ba2005fe8829ac7f66d97e5bc2b4dd2aa011ef25d673b4284d1a5b51

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-09-12 18:04:21 UTC

Raw Date: Sun, 12 Sep 93 11:04:21 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Doug Merritt)
Date: Sun, 12 Sep 93 11:04:21 PDT
To<EMAIL_ADDRESS>Subject: Re: nada against the gubbamess...
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

<EMAIL_ADDRESS>(the mischeivious god) said:
>Any way question to that point about about elections...
>
>Who would be ble to be candidates...just anybody ???that would be
>almost as bad as our present system...which has people with no relevant
>experience except in bullshit and fait de con.

Sorry to say that you're a bit confused. The question was how to provide
justice under anarchy. I said something about voting. You jumped to the
assumption that I was talking about voting for government elections. This
is not the case. I was talking about voting on issues of justice, as
in a jury. You may want to reread my post with this in mind.

As for voting for government in cyberspace, it all depends on the other
assumptions. Should there be a virtual government? Should voting for
physical-world governments take place on the net? Etc, etc. There is
currently no active discussion going on about any of this, so there is no
framework for commenting on voting for such things.
	Doug

{% endraw %}
```

## Thread

+ Return to [September 1993](/archive/1993/09)

+ Return to<EMAIL_ADDRESS>(Doug Merritt)](/authors/doug_at_netcom4_netcom_com_doug_merritt_)"

+ 1993-09-12 (Sun, 12 Sep 93 11:04:21 PDT) - Re: nada against the gubbamess... -<EMAIL_ADDRESS>(Doug Merritt)_


text:
# lobsolution.net
## Inventory Management Solution

I started this project because I wanted to apply all my 20+ years of software development in designing the best product I could.
Everytime I learn a new technology, which can be useful for this, I just use it, even if I have to rewrite a lot of code.
Right now the source code is still not open, but it will probably be soon.
I used all open source technologies with free licence as this is a free version.
For an Enterprise/Custom version, buying licences may be required.

If you want to try it, the demo of the latest version is at: http://demo.lobsolution.net

This user is read-only.

Username:
<EMAIL_ADDRESS>
Password:
Demo111$

I hope you enjoy it!

This docker compose file is to spin-up the entire infrastructure.

# Prerequisite
- Docker installed (https://www.docker.com/get-started)
- At least 8GB of RAM assigned to Docker

# Usage
- Download the docker-compose.yml file
- Open a Powershell/Bash shell and point to the directory where you downloaded the file
- type:
    docker-compose up -d
- open the browser and go to http://localhost:5030

As this is a free version, the HTTPS is not enabled.

# DESIGN
- DDD (Domain Driven Development)
- Microservices
- Event Driven
- State Machine
- SSO (Single Sign On)
- OAuth2/OpenId Connect

# TECHNOLOGIES
- Frontend
  - HTML
  - CSS
  - JQuery
  - TypeScript
  - JavaScript
  - Angular 7
  - Bootstrap 5
  - PrimeNG
  - AdminLTE

- Backend
  - C#
  - .NET CORE 3.1
  - SqlServer 2019

- Infrastructure
  - IdentityServer4
  - Confluent Kafka
  - Elasticsearch
  - Kibana
  - Docker

# FUNCTIONALITIES
  - Dashboard
- INVENTORY
  - Color
  - Size
  - Category
  - Category Group
  - Product
  - Stock Movement
  - Stock Location
- PURCHASE
  - Bill Type
  - Bill
  - Purchase Type
  - Purchase Order
  - Payment Source
  - Purchase Payment
  - Goods Received Note
  - Supplier Type
  - Supplier
- SALES
  - Customer Type
  - Customer
  - Sale Type
  - Shipment Method
  - Sale Order
  - Shipment
  - Invoice Type
  - Invoice
  - Sale Payment
  - Promotion
- ADMINISTRATION
  - User
  - User Roles
  - Custom Roles
  - CONFIGURATION
  - System
  - Company
  - Branch
  - Warehouse
  - Payment Method
  - Currency
  - Unit of Measure
  - Tax Code
- INTEGRATION
  - Import

repository: lobsolution-net/docker-compose

repo_name: lobsolution-net/docker-compose


text:
# Changelog

## [0.3.0] - 2022-07-20

## Changes
* Adds async adapter for Django

## [0.2.4] - 2022-07-14

### Changes
* Fix DjangoAdapter behavior

## [0.2.0] - 2022-03-17

### Changes
* Migrate to poetry
* Update dependencies

### Added
* Python 3.10 support

## [0.1.1] - 2020-06-04

### Changes

* Ignore request cache key operations when it is not configured

## [0.1.0] - 2020-05-15
### Changes
* Args `failure_timeout` and `circuit_timeout` of CircuitBreaker to have a default value
* Call `expire` after `incr` to prevent keys on storage without TTL
* Remove unnecessary `storage.add` calls

### Added
* Upload to pypi on travis CI
* Expire method on storage interface
* DjangoAdapter an adapter to django cache framework

## [0.0.2] - 2020-04-28
### Added
* Typing hint all classes and functions
* `mypy` and `black` on `make check` recipe (which is runned in each CI job)

## [0.0.1] - 2020-04-08
* First Release :tada:

repository: luizalabs/lasier

gha_language: Python

repo_name: luizalabs/lasier


text:
# Vue 3 + Mapbox

This is a demo app using Vue 3 with Reactive and Mapbox. The demo shows pipe data set to Mapbox and buttons that change the color of each pipe by the pipe's properties.

## Project setup
```
yarn install
```

### Compiles and hot-reloads for development
```
yarn serve
```

### Compiles and minifies for production
```
yarn build
```

### Lints and fixes files
```
yarn lint
```

### Customize configuration
See [Configuration Reference](https://cli.vuejs.org/config/).

repository: ctrinh/vue-mapbox

repo_name: ctrinh/vue-mapbox


text:
TimeBlock
=========

TimeBlock is composed by a couple of macros:

* traceElapsedTimeInBlock: A simple little helper to measure the time spent for executing a block.
* traceSlowExecutionBlock: Similar to the first one but just log if the block takes more than a indicated amount of seconds.

## Usage

```
traceElapsedTimeInBlock (@"Log message", ^{
  // Write here the code you want to measure
});
```

```
traceSlowExecutionBlock (@"Log message", 25, ^{
  // Write here the code you want to log if it takes more than 25 seconds on runtime
});
```

## Installation with CocoaPods

### Podfile
```
pod 'TimeBlock', :git => 'https://github.com/dcordero/TimeBlock'
```

repository: dcordero/TimeBlock

repo_name: dcordero/TimeBlock


text:
# Punton Music Player Desktop
[![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://opensource.org/licenses/MIT)
> A music player with Machine Learning techniques.
##TODO LIST

1. Implement Javascript MFCC extraction for better extraction.
2. Using CAE (Convolutional Autoencoder) with MFCC for better accuracy
3. Rewrite code in TFJS (TensorflowJavaScript)

## Abstraction
We report our work on exploring techniques to automatically generate the playlists for personal media player. The proposed approach intends to be able to perform on a standard personal computer platform. Given the first song, the system automatically generates the playlist from personal music collection based on the continuity of the melody and rhythm. Our technique relies only on the feature generated directly from the audio signal to avoid the problem that could arise from the lack of song tags and metadata. Two techniques, namely kd-tree and dynamic time warping, were evaluated and compared in terms of user satisfaction on the generated playlist and the execution time.

## Background and motivation
Nowadays, there are various genres of music and different people have their own taste of music. Music also has been used differently in order to create atmosphere for users while they are listening to songs. From many researches, music could be apply to many other things such as using it to abbreviate the disease or ease the pain or sorrow for any patiences. These prove the importance of the music in our life style. There is a quote from Plato state that “Music is a moral law. It gives soul to the universe, wings to the mind, flight to the imagination, and charm and gaiety to life and to everything. “ ㅡ Plato, 428 BC.
While there are many music classifiers that group music by the genre of the music or the category of music, these conditions might not be able to satisfy the user’s need in their daily lives. Rather than each individual person has to spend a lot of time each day surfing for songs they desire to listen to which wastes a lot of invaluable time. As a result, we have come up with the method of suggesting the music to users that don’t require them to surf which is by providing suggested lists of music that they prefer.

## Scope
The scope of this project is as follows:
1. Develop Recoomendation that can generate the playlist based on user current moods.
2. Considered data source are sound wave of songs.
3. Application has user interface with good user experience which makes users do not have to learn how to use.
4. Cross-platform Desktop application serves different operating system users.
5. Machine learning technique separates group of song when users import new songs to application.
#### Build Setup

``` bash
# install dependencies
yarn

# serve with hot reload at localhost:9080
yarn dev

# build electron application for production
yarn build

# run unit & end-to-end tests
yarn test

# lint all JS/Vue component files in `src/`
yarn lint

```

---

This project was generated with [electron-vue](https://github.com/SimulatedGREG/electron-vue)@[1c165f7](https://github.com/SimulatedGREG/electron-vue/tree/1c165f7c5e56edaf48be0fbb70838a1af26bb015) using [vue-cli](https://github.com/vuejs/vue-cli). Documentation about the original structure can be found [here](https://simulatedgreg.gitbooks.io/electron-vue/content/index.html).

repository: punton/punton-music-desktop

gha_language: Jupyter Notebook

repo_name: punton/punton-music-desktop