text:
# create-embedded-map.rb

Language: [Ruby](https://www.ruby-lang.org/).

Prerequisite: Gem [redcarpet](https://github.com/vmg/redcarpet)

Creates a map with optional markers.

Call: `[external-caller="ruby self://bin/create-embedded-map.rb"]`

Arguments: None.

Stdin: YAML file with map definitions.

Output: JSON. The JSON output is processed by this plugin. And HTML is placed to the page. This indirection and its use is described [here](../README.md#return-json).

## Install prerequisites

Ruby, of course. See [here](https://www.ruby-lang.org/en/documentation/installation/).

And the gems redcarpet, fast_gettext.

```sh
$ [sudo] gem install redcarpet
```

See [here](https://github.com/vmg/redcarpet#you-can-totally-install-it-as-a-gem).

```sh
$ [sudo] gem install fast_gettext
```

See [here](https://github.com/grosser/fast_gettext#setup).

## Scheme to call this program

~~~md
[external-caller="ruby self://bin/create-embedded-map.rb"]
```
---
provider: leaflet
geo: 38.89768,-77.03656?z=13
width: 700
height: 400
poi:
  -
    description: 'The White House'
    geo: 38.89768,-77.03656
    anchor: 'loc_white_house'
    color: red
    badge: A
...
```
[/external-caller]
~~~

The configuration is a [YAML](https://yaml.org/) file. You must enclose this in [block code fences](https://learn.getgrav.org/16/content/markdown#block-code-fences) to keep the indentation, which is essential to YAML.

### Parameters

| Parameter  | Description                                                  |
| ---------- | ------------------------------------------------------------ |
| `provider` | (Optional) Provider of the displayed map.
Possible values: `leaflet`
A map without map provider defaults to `leaflet`. |
| `geo`      | Location of the center of the map.
Scheme: `LATITUDE,LONGITUDE[?z=ZOOM-FACTOR]`
`LATITUDE` and `LOGITUDE` are floating point values. The zoom factor is optional. It defaults to 16. |
| `locale`   | (Optional) Locale of map.
Possible values: `en`, `de` and all the other locales you define in `bin/locales` directory of the plugin. It defaults to `en`. |
| `width`    | Width of map in pixel.                                       |
| `height`   | Height of map in pixel.                                      |
| `poi`      | (Optional) Array of hashes (associative array) of POI (point of interest). |

#### POI

| Parameter     | Description                                                  |
| ------------- | ------------------------------------------------------------ |
| `description` | (Optional) Literally description of POI.
Value: String.
The description is processed as markdown. Feel free to add links, formatting and so on. |
| `geo`         | Location of the POI.
Scheme: `LATITUDE,LONGITUDE`
`LATITUDE` and `LOGITUDE` are floating point values. No zoom factor here. 😱 So, the marker may not be visible on the map. |
| `anchor`      | (Optional) Name of an page anchor.
Value: String.
Syntax restrictions see [here](https://www.w3schools.com/hTML/html_id.asp). „The name is case sensitive. The name must contain at least one   character, and must not contain whitespaces (spaces, tabs,   etc.).“
On other Grav pages you may refer these POI. Say the anchor is `loc_town_hall` on page `map`. You may link it with:  `[Town Hall](map#loc_town_hall)` |
| `color`       | (Optional) HTML/CSS color of the map marker. Syntax restrictions see [here](https://www.w3schools.com/CSSref/pr_text_color.asp). POI without specific color default to an internal color scheme. |
| `badge`       | (Optional) Text for the center of the marker. Should be very short! One, two or three characters. POI without badge are numbered up beginning with 1. |

## Example

```md
[external-caller="ruby self://bin/create-embedded-map.rb"]
```
---
provider: leaflet
locale: en
geo: 38.89768,-77.03656?z=13
width: 700
height: 400
poi:
  -
    description: '[The White House](https://en.wikipedia.org/wiki/White_House), Washington, D.C.'
    geo: 38.89768,-77.03656
    anchor: 'loc_white_house'
    color: red
    badge: A
  -
    description: 'Restaurant [Oyamel Cocina Mexicana](https://www.oyamel.com/)'
    geo: 38.89494,-77.02167
  -
    description: 'Restaurant [BLT Steak](https://bltrestaurants.com/blt-steak/washington-d-c/)'
    geo: 38.90172,-77.03760
  -
    description: 'Restaurant [Taylor Gourmet](http://taylorgourmet.com/)'
    geo: 38.90585,-77.04371
  -
    description: 'Restaurant [Minibar](http://www.minibarbyjoseandres.com/minibar/)'
    geo: 38.89632,-77.02358
  -
    description: 'Restaurant [Good Stuff Eatery](http://goodstuffeatery.com/locations/capitol-hill)'
    geo: 38.88660,-77.00179
  -
    description: 'Restaurant [Rose’s Luxury](https://www.rosesrestaurantgroupdc.com/)'
    geo: 38.88064,-76.99528
  -
    description: 'Restaurant [Blue Duck Tavern](https://www.blueducktavern.com/?src=vanity_blueducktavern.com)'
    geo: 38.90553,-77.05116
  -
    description: 'Restaurant [Ray’s Hell Burger](http://www.rayshellburger.com/)'
    geo: 38.90282,-77.01777
  -
    description: 'Restaurant [Restaurant Nora](http://www.noras.com/)'
    geo: 38.91275,-77.04727
...
```
[/external-caller]
```


text:
---
page_type: sample
languages:
  - csharp
name: Quickstart in C#
description: "Learn basic steps in C# for creating, loading, and querying an Azure Cognitive Search index in a .NET Core console application."
products:
  - azure
  - azure-cognitive-search
urlFragment: csharp-quickstart
---

# Quickstart sample for Azure Cognitive Search in .NET

![Flask sample MIT license badge](https://img.shields.io/badge/license-MIT-green.svg)

Demonstrates using the Azure Cognitive Search .NET SDK to create an index, load it with documents, and execute a few queries. The index is modeled on a subset of the Hotels dataset, reduced for readability and comprehension. Index definition and documents are included in the code.

This .NET Core console application is featured in [Quickstart: Create your first app - Azure Cognitive Search](https://docs.microsoft.com/azure/search/tutorial-csharp-create-first-app). When you run the program, a console window emits output messages for each step: deleting and then re-creating a hotels-quickstart index, loading documents, running queries. This sample uses the [.NET SDK](https://docs.microsoft.com/dotnet/api/?term=microsoft.azure.search) and runs on an Azure Cognitive Search service using connection information that you provide.

## Contents

| File/folder | Description |
|-------------|-------------|
| `AzureSearchQuickstart.sln`       | .NET Core console solution file |
| `AzureSearchQuickstart`       | Source files |
| `.gitignore` | Define what to ignore at commit time. |
| `CONTRIBUTING.md` | Guidelines for contributing to the sample. |
| `README.md` | This README file. |
| `LICENSE`   | The license for the sample. |

## Prerequisites

- [Visual Studio](https://visualstudio.microsoft.com/downloads/)
- [Azure Cognitive Search service](https://docs.microsoft.com/azure/search/search-create-service-portal)

## Setup

1. Clone or download this sample repository.
1. Extract contents if the download is a zip file. Make sure the files are read-write.

### Running quickstart
1. Open the AzureSearchQuickstart.sln project in Visual Studio
1. Update the appsettings.json with the service and api details of your search service
1. Compile and Run the project

## Next steps

You can learn more about Azure Cognitive Search on the [official documentation site](https://docs.microsoft.com/azure/search).

license: MIT

repository: manalotoj/azure-search-dotnet-samples

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: manalotoj/azure-search-dotnet-samples


text:
# Embeddinator-4000 0.2

This is the second public release of Embeddinator-4000. It supports the Objective-C language on macOS, iOS, and tvOS. More languages and platforms will be added in future releases.

Requirements
============

* macOS 10.12 (Sierra) or later;
* Xcode 8.3.2 or later;
* Mono 5.0 or later;

Optional
--------

* [Visual Studio for Mac](https://www.visualstudio.com/vs/visual-studio-mac/);
* [Xamarin.iOS <IP_ADDRESS> or later](https://jenkins.mono-project.com/view/Xamarin.MaciOS/job/xamarin-macios-builds-master/) **Links to preview builds**. Required for iOS and tvOS support;
* [Xamarin.Mac <IP_ADDRESS> or later](https://jenkins.mono-project.com/view/Xamarin.MaciOS/job/xamarin-macios-builds-master/) **Links to preview builds**. Required for standalone macOS support;

What's New
==========

- tvOS support - [pr329](https://github.com/mono/Embeddinator-4000/pull/329)
- Improved behavior when generated code would duplicate other library or system selectors.

Objective-C Support
-------------------
* [pr284](https://github.com/mono/Embeddinator-4000/pull/284) - [interop] Added support for `IFormatProvider` as a Objective-C protocol;
* [pr299](https://github.com/mono/Embeddinator-4000/pull/299) - [interop] Added support for managed types implementing `IEquatable<T>`;
* [pr292](https://github.com/mono/Embeddinator-4000/pull/292) - [interop] `System.Decimal` is now mapped with Foundation's `NSDecimalNumber`
* [pr315](https://github.com/mono/Embeddinator-4000/pull/315) - [generator] Better names are generated when types are used
* [pr344](https://github.com/mono/Embeddinator-4000/pull/344) - [interop] Added support for conversion between `NSDate` and `DateTime`.
* [pr332](https://github.com/mono/Embeddinator-4000/pull/332) - [objc] Add decimal array ref support
* [pr327](https://github.com/mono/Embeddinator-4000/pull/327) - [objc] Add support for System.TimeSpan into generated projects

iOS Support
-----------

* [pr305](https://github.com/mono/Embeddinator-4000/pull/305) - [mtouch] Native symbols stripping now supported with Xamarin.iOS in embeddinator mode
* [pr319](https://github.com/mono/Embeddinator-4000/pull/319) - [linker] Automatically create XML file to preserve anything required from SDK assemblies;

macOS Support
-------------

* [pr324](https://github.com/mono/Embeddinator-4000/pull/324) - [mmp] Support for native frameworks generated with Xamarin.Mac;
* [pr324](https://github.com/mono/Embeddinator-4000/pull/324) - [registrar] Support for subclassing managed subclasses of `NSObject` from Xamarin.Mac based assemblies;

note: macOS support _without Xamarin.Mac_ remains supported but requires a compatible version of Mono to be installed on the computer;

tvOS Support
------------

* [pr329](https://github.com/mono/Embeddinator-4000/pull/329) - Support for tvOS is now available. It requires Xamarin.iOS to be installed;

Other New Features
------------------

* [pr339](https://github.com/mono/Embeddinator-4000/pull/339) - [driver] The command line tool now support `nowarn:` to reduce the number of warnings (e.g. when binding an assembly that cannot be modified);
* [pr339](https://github.com/mono/Embeddinator-4000/pull/339) - [driver] The command line tool now support `warnaserror:` to ensure some warnings cannot be overlooked;

Known Issues
============

* This release only generates Objective-C code;
* This release only targets macOS, iOS, and tvOS - the latter requires Xamarin.iOS (10.11+) to be installed;
* Some C# features (e.g. generics) are not yet supported;
* In some cases the generator produces duplicate symbols, which won't compile. Please file issues on github if this occurs.

A list of issues, including bugs, enhancements and ideas, is being tracked on [github](https://github.com/mono/Embeddinator-4000/issues).


text:
# Remove System Apps
- This is a macOS bash script I made just for the sake of it.
- This removes apps, backups apps to the desktop, or moves the apps defined by the script to a safe place.
- I made this because I saw a tweet from @mem_alloc on Twitter who had said he wanted to remove those apps (I don't really recommend removing them but hey...)

# How to use?
- Simple! Download or Clone to Desktop and open terminal then chmod +x removeapps (if needed).
- Double click the script file and it will take care of the rest.
- Need help contact me on Twitter @iKilledAppl3.

# Things to Do!
- Add the abilty for users to choose what apps they want to delete, make a backup of, or move out of the /Applications/ directory.

# Licensed under the MIT License!
Respect all the license states so on and so forth!

# Donate!
- What's the best thing you can do to help me out?
- Simple! DONATE!
- Donate here: http://is.gd/donate2ToxicAppl3Inc

# The tweet that inspired it :P
Twitter Status: https://twitter.com/mem_alloc/status/903078876313739264


text:
---
sidebar: auto
---

## Getting Started

FormVueLatte is a zero dependency library that allows you to generate schema-driven forms with extreme ease.

The schema that you use for your form can be as flexible as you need it to be, it can be modified at run-time with an expected reactive result, and can even be fetched directly from you backend's API.

### Installation

To add FormVueLatte to your project, start by installing the package through your favorite package manager.

```bash
yarn add formvuelatte

// OR

npm install formvuelatte
```

Now that you have the package in your project, `import` it to your component.

```js
import { SchemaForm } from 'formvuelatte'
```

The `SchemaForm` requires two `props`. The first is the `schema`, which is the configuration of your form. The second one is `value`, which will hold the state of the form.

```html
<SchemaForm :schema="mySchema" :value="formData" />
```

The `SchemaForm` will `$emit` **input** events when your components update. This means that you are able to either use `v-model` on it, or manually capture the `@input` event with a method of your own, as well as inject the `:value` property. Either or.

Below you will find an example of the previous concepts.

```html
<template>
  <SchemaForm :schema="mySchema" v-model="formData" />
</template>

<script>
export default {
  data() {
    return {
      formData: {},
      mySchema: {
        //some schema here
      }
    }
  }
}
</script>
```

## The schema prop
The `SchemaForm` component requires you to pass it a `schema` property. This `schema` can be both an `object` or an `array`, although under the hood it will be transformed to an `array`.

In its simplest form, the `schema` requires you to provide a `name: value` pair for each of the form components you want to add to your form. Let's assume for this example that you have a component in your project called `FormText` which exposes an `<input>` tag with some CSS.

```html
<template>
    <SchemaForm :schema="schema" />
</template>

<script>
    import { SchemaForm } from 'formvuelatte'
    import FormText from 'path/to/FormText';

    export default {
        components: { SchemaForm },
        data() {
            return {
                schema: {
                    name: {
                        component: FormText // Note that is NOT a string
                    },
                    lastName: {
                        component: FormText // We pass the component that we imported directly
                    }
                }
            }
        }
    }
</script>
```

## Component Requirements and the FormMixin
Now that you have your schema bound into the `schema` prop, you need to make sure that your components are understood by `SchemaForm`.

In order for `SchemaForm` to understand **your components**, they need to use the `FormMixin` mixin that FormVueLatte provides.

```js
// FormText.vue
import { FormMixin } from 'formvuelatte'
export default {
  [...]
  mixins: [ FormMixin ],
  [...]
}
```

In its simplest form, make sure that when your `form element` wants to make a change to the `value`, it calls the `update` method with the new value.

Here's an example using the `<input>` tag.

```html
<input
    :value="value"
    @input="update($event.target.value)"
/>
```

The `FormMixin` adds a required `value` property to your component (for it to comply with v-model capabilities).

Once you've imported the mixin to your components, make sure your component makes use of the `update` method provided by the mixin.

The `update` method `$emit`s the `input` event with whatever value you pass to it.

## Examples
Here you will find a few examples on how you can set up your `schema` and the output it would produce.

Please note: We are using a few different custom components to showcase, but you should use your own! 😉

### Basic Usage
In this example you can see `SchemaForm` being used in its simplest form.

A local SCHEMA is created, and passed into the `schema` property, which in return renders the function.

#### Schema

```js
const SCHEMA = {
  firstName: {
    component: FormText,
    label: 'First Name',
  },
  lastName: {
    component: FormText,
    label: 'Last Name',
  },
  email: {
    component: FormText,
    label: 'Your email',
    required: true,
    config: {
      type: 'email'
    }
  },
  isVueFan: {
    component: FormCheckbox,
    label: 'Are you a Vue fan?'
  }
}
```

#### Template
```js
<SchemaForm
    :schema="schema"
    v-model="userData"
/>
```

<SplitTab>
  <ExampleVModel slot="example"/>
  <<< @/docs/.vuepress/components/ExampleVModel.vue
</splitTab>

### With Array Schema
Your schema can be built in two ways, the first way as showcased by other examples is to set up a wrapper object, in which each `property` of this object is the definition of each of the form's components.

```js
let schema = {
  nameOfMyModelProperty: { component: MyCoolComp, label: 'My label' },
  firstName: { component: FormText, label: 'First name' }
}
```

`SchemaForm` also allows you a second way of constructing your schema by setting it as an array of objects. The key difference to observe, other than the actual schema being an `array`, is that each of the elements inside the array must contain a `model` property that defines the name of the element, and also the name of the `key` of the data that is returned.

```js
let schema = [
  { model: 'nameOfMyModelProperty', component: MyCoolComp, label: 'My label' },
  { model: 'firstName', component: FormText, label: 'First name' }
]
```

<SplitTab>
  <ArrayExample slot="example" />
  <<< @/docs/.vuepress/components/ArrayExample.vue
</SplitTab>

### V-Model Example
`SchemaForm` can be used in conjunction with `v-model` to bind the results of the form with your state.

<SplitTab>
  <ExampleVModel slot="example" />
  <<< @/docs/.vuepress/components/ExampleVModel.vue
</SplitTab>

### Modal Example
This example showcases the `SchemaForm`s ability to handle a complex component in the schema. We add an `EmailModal` component to the schema, which displays a `<button>` in the form, when clicked, this button opens a modal with two input fields.

As long as the component can handle the `value` injection from the `SchemaForm`, and fires an `input` event when the internal data changes, `SchemaForm` will be able to handle the change and append it to the form's data.

```html
<!-- EmailModal.vue  -->
<template>
  <div>
    <BaseButton class="baseButton" type="button" @click="modalShown = !modalShown">Email</BaseButton>

    <Modal v-if="modalShown">
      <p>Configure your email:</p>
      <FormText label="Title" v-model="values.title" />
      <FormText label="Content" v-model="values.content" />

      <BaseButton @click="save">Save</BaseButton>
      <BaseButton @click="modalShown = false">Cancel</BaseButton>
    </Modal>
  </div>
</template>

<script>
import FormText from './FormText';
import BaseButton from './BaseButton';
import Modal from './Modal';

export default {
  components: { Modal, BaseButton, FormText },
  props: {
    value: { required: true }
  },
  data() {
    return {
      modalShown: false,
      values: {...this.value}
    }
  },
  methods: {
    save() {
      this.$emit('input', {
        ...this.value,
        ...this.values
      });

      this.modalShown = false
    }
  }
}
</script>
```

<SplitTab>
  <ModalExample slot="example" />
  <<< @/docs/.vuepress/components/ModalExample.vue
</SplitTab>

### Nested SchemaForms
Similarly to the Nested Schema Modal example, you can also pass in a `SchemaForm` component directly to your schema, with a schema property of itself.

Be aware that the data provided by the nested `SchemaForm` will also be nested in the output data.

<SplitTab>
  <Formception slot="example" />
  <<< @/docs/.vuepress/components/Formception.vue
</SplitTab>

### Schema Modal with Nested Example
`SchemaForm` can even be used in conjunction inside components as a sub-renderer.

In this example, we have added a property `schema` to the `EmailModal`, if this property is set with a schema of itself, it will render additional input fields on our modal by making use of a nested `SchemaForm` component.

Notice in the `EmailModal.vue` example that we now render a sub instance of `<SchemaForm>` when the `schema` property is set.

The actual schema in the example now includes a `schema` property for `EmailModal` that nests a schema of its own.

```html
<!-- EmailModal.vue -->
<template>
  <div>
    <BaseButton class="baseButton" type="button" @click="modalShown = !modalShown">Email</BaseButton>

    <Modal v-if="modalShown">
      <template v-if="!schema">
        <p>Configure your email:</p>
        <FormText label="Title" v-model="values.title" />
        <FormText label="Content" v-model="values.content" />
      </template>

      <template v-if="schema">
        <SchemaForm :schema="schema" v-model="values" />
      </template>

      <BaseButton @click="save">Save</BaseButton>
      <BaseButton @click="modalShown = false">Cancel</BaseButton>
    </Modal>
  </div>
</template>

<script>
import FormText from './FormText';
import BaseButton from './BaseButton';
import Modal from './Modal';

export default {
  components: { Modal, BaseButton, FormText },
  props: {
    value: { required: true },
    schema: { type: Object, required: false }
  },
  data() {
    return {
      modalShown: false,
      values: {...this.value}
    }
  },
  methods: {
    save() {
      this.$emit('input', {
        ...this.value,
        ...this.values
      });

      this.modalShown = false
    }
  }
}
</script>
```

<SplitTab>
  <SchemaModalExample slot="example" />
  <<< @/docs/.vuepress/components/SchemaModalExample.vue
</SplitTab>

### MultiElement

The `SchemaForm` can handle custom components that wrap two or more child inputs.
They must emit the `update-batch` event with an object payload that has the values for each of the inputs.

<SplitTab>
  <MultiElementExample slot="example" />
  <<< @/docs/.vuepress/components/MultiElementExample.vue
</SplitTab>

### Shared Config

The `SchemaForm` includes a prop `sharedConfig` that applies a configuration object to all the elements in the form.

In the following example, the prop `readOnly` is being globally applied to all the child components in the form, the `FormText` component disables and changes the color of the background when `readOnly` is set to true internally.

<SplitTab>
  <SharedConfigExample slot="example" />
  <<< @/docs/.vuepress/components/SharedConfigExample.vue
</SplitTab>

### Schema Wizard
**FormVueLatte** ships also with a `SchemaWizard` component, which takes an `array` of schema objects, and a `step` property which is 0 based.

It will render the correct `SchemaForm` based on the current `step`, and is fully `v-model` ready.

It exposes a `default` slot that can be used to add control buttons for next and back, if necessary.

<SplitTab>
  <WizardExample slot="example" />
  <<< @/docs/.vuepress/components/WizardExample.vue
</SplitTab>


text:
# SNAP Framework Hardware and Software

# 1. Overview
The SNAP Framework enables programmers and computer engineers to quickly create FPGA-based acceleration actions that work on server host data, as well as data from storage, flash, Ethernet, or other connected resources.  SNAP, therefore, is an acronym for “**S**torage, **N**etwork, and **A**nalytics **P**rogramming”.
The SNAP framework makes it easy to create accelerated actions utilizing the IBM **C**oherent **A**ccelerator **P**rocessor **I**nterface (CAPI).
![snap_concept_diagram](/doc/snap_concept_diagram.png "SNAP")
The framework hardware consists of a AXI-to-CAPI bridge unit, memory-mapped register I/O, host DMA, and a job management unit.
It interfaces with a user-written action (a.k.a. kernel) through an AXI-lite control interface, and gives coherent access to host memory through AXI. Optionally, it also provides access to the on-card DRAM via AXI.
A NVMe host controller-AXI bridge complements the framework for storage or database applications as an independent unit.
Software gets access to the action through the libsnap library, allowing applications to call a "function" instead of programming an accelerator.
The framework supports multi-process applications and can be extended to support multiple instantiated hardware actions in parallel.
**Note:** The current 1.x releases support a single action per FPGA.

This project is an initiative of the OpenPOWER Foundation Accelerator Workgroup.
Please see here for more details:
* https://members.openpowerfoundation.org/wg/ACLWG/dashboard
* http://openpowerfoundation.org/blogs/capi-drives-business-performance/

## What is CAPI, education materials and more information
* CAPI and SNAP on IBM developerworks: https://developer.ibm.com/linuxonpower/capi/
* [IBM Developerworks Forum, tag CAPI_SNAP (to get support)](https://developer.ibm.com/answers/smartspace/capi-snap/index.html)
* [Education Videos](https://developer.ibm.com/linuxonpower/capi/education/)

## Status
Currently the SNAP Framework supports CAPI1.0 on POWER8 based hosts and CAPI2.0 on POWER9 based hosts. A similar OpenCAPI SNAP framework is going to be added in a new repository. Users working on SNAP today can easily transfer their CAPI1.0 work to CAPI2.0 or OpenCAPI as the interface for "**Software Program**" and "**Hardware Action**" (shown in the yellow areas of the above figure) will stay the same.

# 2. A 3 steps process
Developing an FPGA accelerated application on SNAP can be done following the steps listed below, but this sequence is not mandatory.

* **Preparation**: Decide the software function to be moved to FPGA. This function, usually computation intensive, is named as "action" in the following description.

* **Step1**. Put the action code into a separate function in the main software code, and determine the function parameters required. Add the few libsnap API functions that required to set up CAPI to the main software. The best way is to start from an example (See in [actions](./actions)) and read the code within the "sw" directory.

* **Step2**. Write the "hardware action" in a supported programming language, such as Vivado HLS or Verilog/VHDL. For **HLS**, developers can write their algorithms in C/C++ syntax within an function wrapper "hls_action()". Developers who prefer **HDL(Verilog/VHDL)**, can use their adapted version of "action_wrapper.vhd" as top-level. It includes several AXI master interfaces and one AXI-lite slave interface. Refer to the "hw" directory in "hls_\*" or "hdl_\*" for action examples.
For **simulation** of the hardware action, the PSLSE (**P**ower **S**ervice **L**ayer **S**imulation **E**ngine) provides a software emulation of the whole path from **libcxl** library to the **P**ower **S**ervice **L**ayer (see the blue boxes in the picture above). This allows for simulating the action without access to an FPGA card or a POWER system. When the simulation is successful, you are ready to **generate the FPGA bitstream**.
**Note** : there is no need to build a specific testbench to test your application in FPGA. This is a key advantage as your code is the testbench.
Please read the [hardware/README.md](hardware/README.md) for more details.

* **Step3**. Program the bitstream to a real FPGA card plugged into a **POWER or OpenPOWER** machine and run your calling software from it. This step is also called **Deployment**.
Please see [Bitstream_flashing.md](hardware/doc/Bitstream_flashing.md) for instructions on how to program the FPGA bitstream.

For a step-by-step help, please refer to the SNAP Workbooks in the [doc](./doc) directory. For example, make sure you read the [QuickStart Guide](./doc/UG_CAPI_SNAP-QuickStart_on_a_General_Environment.pdf) if you're a first time user. Some other user application notes are also there.

Please also have a look at [actions](./actions) to see several examples which may help you get started with coding. Each example has a detailed description in its own "doc" directory.

# 3. Dependencies
## 3.1 FPGA Card selection
As of now, the following FPGA cards can be used with SNAP _(see [cards ressources details](./doc/README.md#p8-capi10-snap-fpga-supported-boards))_ :
* for POWER8 (CAPI1.0):
  * Alpha-Data ADM-PCIE-KU3        http://www.alpha-data.com/dcp/products.php?product=adm-pcie-ku3
  * Alpha-Data ADM-PCIE-8K5 (rev2) http://www.alpha-data.com/dcp/products.php?product=adm-pcie-8k5
  * Nallatech 250S-2T with two on-card NVMe M.2 960GB drives http://www.nallatech.com/250s
  * Semptian NSA121B http://www.semptian.com/proinfo/10.html
* for POWER9 (CAPI2.0):
  * Nallatech 250SP  http://www.nallatech.com/250sp
  * Flyslice FX609 http://www.flyslice.com/page434?product_id=27
  * Semptian NSA241 http://www.semptian.com/proinfo/126.html
  * ReflexCES XpressVUP LP9P https://www.reflexces.com/products-solutions/other-cots-boards/xilinx/xpressvup
  * Alpha-Data ADM-PCIE-9V3 https://www.alpha-data.com/dcp/products.php?product=adm-pcie-9v3

## 3.2 Development (Step1 & Step2)
Development is usually done on a **Linux (x86) computer** since as of now, Xilinx Vivado Design Suite is supported only on this platform.
See examples of [supported development configurations](./doc#p8-development-environments-).
The required tools and packages are listed below. Web access to github is recommended to follow the build instructions. A real FPGA card is not required for the plain hardware development.

### (a) Install Xilinx Vivado Design Suite: the tool to build and program the FPGA.
SNAP currently supports Xilinx FPGA devices, exclusively. For synthesis, simulation model and FPGA/image build, the [Xilinx Vivado HL Design Edition 2018.1 tool suite](https://www.xilinx.com/products/design-tools/vivado.html) is recommended. Different **licenses** are available. Some licenses are limiting the components that can be used; check the FPGA you target. (CAPI1.0 cards use UltraScale family components and CAPI2.0 cards use UltraScale+ family components).
This Design Suite includes a C synthesizer (Vivado HLS), a simulator (xsim), a synthesizer and FPGA/Image build tools (Vivado).

### (b) Download CAPI1.0 PSL or CAPI2.0 BSP: the "connection box" between the POWER server and the FPGA.
Access to CAPI from the FPGA card requires the **P**ower **S**ervice **L**ayer (**PSL**) for CAPI1.0 cards or the **B**oard **S**upport **P**ackage (**BSP**) for CAPI2.0 cards. After accepting the terms of conditions, user will need to download a file to build the FPGA code.
Detailed information is available in [hardware/README.md](hardware/README.md#capi-board-support-and-psl-for-image-build)

### (c) Install the basics for the Build process
First clone snap (https://github.com/open-power/snap.git). Then use the usual development tools: `gcc, make, sed, awk` to build the code and to run the make environment. If not installed already, the installer package `build-essential` will set up the most important tools.

Configuring the SNAP framework via `make snap_config` will call a standalone tool that is based on the Linux kernel kconfig tool. This tool gets automatically cloned from https://github.com/guillon/kconfig

The `ncurses` library must be installed to use the menu-driven user interface for kconfig.

Please see [Image and model build](hardware/README.md#image-and-model-build) for more information on the build process.

### (d) Download the PSL Engine for Simulation: the "POWER + FPGA" emulation box
For simulation, SNAP relies on the `xterm` program and on the PSL Simulation Environment (PSLSE) which is free and available on github

https://github.com/ibm-capi/pslse

Please see [PSLSE Setup](hardware/sim/README.md#pslse-setup) for more information.

Simulating the NVMe host controller including flash storage devices requires licenses for the Cadence Incisive Simulator (IES) and DENALI Verification IP (PCIe and NVMe). However, building images is possible without these licenses.
For more information, see the [Simulation README](hardware/sim/README.md).

## 3.3 Deployment (Step3)
Deployment is on a **Power** or **OpenPower server** with an **FPGA card** plugged.
See examples of [supported deployment configurations](doc/README.md#deployment-environments-).

### (a) Install CAPI accelerator library
This code uses **libcxl** to access the CAPI hardware. Install it with the package manager of your Linux distribution, e.g.
`sudo apt-get install libcxl-dev` for Ubuntu.
For more information, please see https://github.com/ibm-capi/libcxl

### (b) Install CAPI programmation tool
SNAP uses the generic program `capi-flash-script` to upload FPGA code/bitstreams into the CAPI FPGA cards. This can be downloaded from https://github.com/ibm-capi/capi-utils. This tool can be used **ONLY** if a CAPI image has already been put once in the FPGA. If not, please follow guidances [here](hardware/doc/Bitstream_flashing.md#initial-programming-of-a-blank-or-bricked-card) or ask help from [CAPI support](https://developer.ibm.com/answers/smartspace/capi-snap/index.html).

# 4. Contributing
This is an open-source project. We greatly appreciate your contributions and collaboration.
Before contributing to this project, please read and agree to the rules in
* [CONTRIBUTING.md](CONTRIBUTING.md)

To simplify the sign-off, you may want to create a ".gitconfig" file in you home by executing:
```
$ git config --global user.name "John Doe"
$ git config --global user.email<EMAIL_ADDRESS>```
Then, for every commit, use `git commit -s` to add the "Signed-off by ..." message.

By default the git repository is read-only. Users can fork the snap repository, make the changes there and issue a pull request.
Even members with write access to this repository can't commit directly into the protected master branch. To contribute changes, please create a branch, make the changes there and issue a pull request.

Pull requests to merge into the master branch must be reviewed before they will be merged.

gha_language: C


text:
# 5 things to know for Monday, November 4, 2019

Published at: **2019-11-04T11:27:00+00:00**

Author: **CTVNews.ca , Staff**

Original: [www.ctvnews.ca](https://www.ctvnews.ca/5things/5-things-to-know-for-monday-november-4-2019-1.4668774)

Two of Ottawa's four planes used for VIP travel will soon face restrictions on where they can fly. Here's what else you need to know to start your day.
1. Challenger jets: The federal government could be forced to buy new executive jets to transport the prime minister and other VIPs because of changes to air-traffic control rules in the U.S. and Europe.
2. Winnipeg stabbing: A memorial continues to grow outside the Winnipeg home of a three-year-old boy who was allegedly stabbed as he slept and later died after being taken off life support.
3. Dog scam: A Quebec woman has been reunited with her German shepherd after a couple on Kijiji encouraged her to give them her dog in an alleged scam.
4. Gut microbiome: A new study suggests a link between certain gut bacteria and an increased risk of bowel cancer, but stops short of concluding that either causes the other.
5. 'Violins of Hope': A collection of violins that belonged to Jewish musicians during the Holocaust were featured for the first time in Canada at a special concert in Montreal over the weekend.

        One more thing…

Retro toys: McDonald's locations across Canada are celebrating 40 years of Happy Meals this month, by bringing back some of their most popular toy giveaways.

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
##Configuring the Operating System For GsDevKit on a Single Remote Node accessed via X-Forwarding

Before you can use a particular machine as part of a GsDevKit configuration, you must ensure that the
appropriate features are installed.   Since to begin with, you will not have git access to the GsDevKit
installation, you must manually install the appropriate packages.

The requirements are different for the different possible configurations and different operating systems.
A description of the various options is [Installation Overview][1].

These instructions are specific to the OS used for installation on a single host.
The instructions are provided [Installation on a remote node with X forwarding][2]

---
###Configure Linux Server for Client and Server

```
  sudo dpkg --add-architecture i386
  sudo apt-get -y update

  sudo apt-get -y install curl
  sudo apt-get -y install git
  sudo apt-get -y install zip
  sudo apt-get -y install unzip
  sudo apt-get -y install libpam0g:i386
  sudo apt-get -y install libssl1.0.0:i386
  sudo apt-get -y install gcc-multilib libstdc++6:i386
  sudo apt-get -y install gdb
  sudo apt-get -y install libfreetype6:i386
  sudo apt-get -y install pstack
  sudo /bin/su -c "echo 'kernel.yama.ptrace_scope = 0' >>/etc/sysctl.d/10-ptrace.conf"

  sudo ln -f -s /usr/lib/i386-lin-gnu/libstdc++.so.6 /usr/lib/i386-linux-gnu/libstdc++.so

  sudo apt-get -y install libgl1-mesa-dev:i386
  sudo apt-get -y install libxcb-dri2-0:i386
```

---
###Configure Mac as X-forwarding Client

```
TBD
```

[1]: ./README.md
[2]: ./README.md#installation-on-a-single-desktop

gha_language: Shell


text:
---
title: "Imprint English"
language: "de"
---

## Address

Healthy Together gGmbH

Urbanstr. 71

10967 Berlin, Germany

### Contact

Tel .: +49 (0) 30 609865290

Email<EMAIL_ADDRESS>
### Managing Directors

Ramin Niroumand

Julian Bernhard Edward Teicke

### Commercial Register

Amtsgericht Charlottenburg

HRB 216639 B

VAT ID: [Aktualisierung nach erfolgreicher Eintragung]

### The following information is legally required according to German law

Responsible for content according to § 55 RStV Abs. 2: Ramin Niroumand, see address above. Note on external links: In a judgment dated 12 May 1998, “Liability for Links” (312 O 85/98) the regional court (LG) of Hamburg decided that the owner of a website is responsible for the contents on linked pages of external websites. This can only be prevented by explicitly distancing oneself from these contents. We hereby disclaim responsibility for the contents of all linked pages on our website and declare that we do not adopt this content as its own.

#### Disclaimer

The information provided on this website has been carefully checked and is updated regularly. However, no guarantee can be given that all information is always complete, correct and / or up to date. This applies especially to all links to other websites, which are directly
or indirectly. We reserve all information to supplement without prior
notice, to remove and / or modify.

### Copyright

All product names mentioned on this website, product names, brand names and logos are trademarks and / or property of their respective owners. All text and graphics on this site: © Gesund Zusammen gGmbH i.G. or the copyright holders.

branch_name: refs/heads/source

gha_language: TypeScript


text:
---
layout: post
title: "Hello Octopress"
date: 2011-12-08 11:18
comments: true
sharing: true
published: true
categories: [tech, octopress, blogging]
---

This is my first post on my new [Octopress](http://octopress.org "Octopress")-powered site.

Prior to today, this site was driven by Wordpress and overall I was fairly happy with it.Wordpress is indeed a powerful platform and as an experienced PHP developer, I can dig into the source code and tweak things to my heart's content. For many of the sites I manage, Wordpress is an excellent option and I will continue to use it for those sites. However, for a simple blog like this, Wordpress tended to get in the way more often than not, and I found I would get caught up in *managing* all the various plugins and themes more often than simply *writing*.

<!-- more -->

### Baked vs. Fried ###

It was around the time of this growing discontent that I stumbled across some articles on *baked blogs* vs. *fried blogs*. Some of the most convincing posts in favour of *baking* came from Brent Simmons, including: [New publishing system / tour of my head](http://inessential.com/2009/01/30/new_publishing_system_tour_of_my_head), [A plea for baked weblogs](http://inessential.com/2011/03/16/a_plea_for_baked_weblogs) and [More on baked blogs](http://inessential.com/2011/03/17/more_on_baked_blogs).

The essential difference between these two approaches is that *fried sites* are build on demand by the user through a database lookup. In general, a fried site (assuming you're not doing any caching) will perform a database lookup for each page view, and hence a large influx of visitors can create such a server load that the site will go down. On the other hand, *baked sites* are built from a bunch of scripts which output static web pages. You generally updates these static pages whenever you add or update a post. It is these static web pages that are then accessed by visitors. Not only can this speed up page load time but it can also protect you from getting [fireballed](http://fireballed.org/).

### Wordpress Alternatives ###

All that got me thinking about looking for a baked alternative to Wordpress, and if I couldn't find the right one I even thought about writing my own from scratch. There was some specific features that was looking for such as being able to write all the blog posts in [Markdown](http://daringfireball.net/projects/markdown/) and of course I wanted something that was written in Ruby. Over the past several years Ruby has become my programming language of choice and so I'm always looking for opportunities to use it.

In my search I first found [Jekyll](https://github.com/mojombo/jekyll), which the static site generator written in Ruby that is used on [Github Pages](http://pages.github.com). If you've visited Github Pages then you've seen Jekyll in action. Jekyll is fantastic but it does require you to create all your own HTML Templates, CSS and any JavaScript from scratch. Wouldn't it be great if someone took Jekyll but then built a framework around it so that it could be complete solution? This is where Octopress comes in.

### Octopress ###

Octopress is exactly the solution I was looking for. Build on the solid foundation of Jekyll, it provides a complete blogging framework with everything you need including:

 * A beautiful semantic HTML5 template
 * A Mobile friendly design
 * Easy deployment
 * Build in support for Twitter, Google+, Disque Comments, etc..
 * Much, much more...

It is incredibly easy to get started with Octopress and the official site at [octopress.org](http://octopress.org) lays out the process step by step. For myself, within about an hour reading the documentation and following the detailed instructions, I had a working site.

I was also able to easily migrate my Wordpress posts over to Markdown files using [Exitwp](https://github.com/thomasf/exitwp). So, if you're a Wordpress user and you're looking for a static blog alternative, no more excuses, you can easily make the switch over to Octopress. I'm definitely glad I did.

extension: markdown


text:
# Git Terminology

- ### Repository
  * **Defintion:** A repository is the most basic element of GitHub. They're easiest to imagine as a project's folder. A repository contains all of the project files (including documentation), and stores each file's revision history. Repositories can have multiple collaborators and can be either public or private.
       ####
     **Example:**
      ![Repository Ex](https://guides.github.com/activities/hello-world/create-new-repo.png)

      **Example 2:**
       ![Repository EX](https://docs.microsoft.com/th-th/azure/devops/learn/_img/git_repositories.png)

- ### Clone
  * **Definition:** A clone is a copy of a repository that lives on your computer instead of on a website's server somewhere, or the act of making that copy. When you make a clone, you can edit the files in your preferred editor and use Git to keep track of your changes without having to be online. The repository you cloned is still connected to the remote version so that you can push your local changes to the remote to keep them synced when you're online.
    ####
     **Example:**
    ![Clone Ex](https://miro.medium.com/max/507/0*LsQht149BNbsiv5x.png)

     **Example 2**
    ![Clone Ex](https://bobbelderbos.com/assets/git-clone.png)

- ### Fork
  * **Definition:** A fork is a personal copy of another user's repository that lives on your account. Forks allow you to freely make changes to a project without affecting the original upstream repository. You can also open a pull request in the upstream repository and keep your fork synced with the latest changes since both repositories are still connected.
    ####
    **Example:**
    ![Fork Ex](https://www.earthdatascience.org/images/earth-analytics/git-version-control/git-fork-emphasis.png)

- ### Branch
  * **Definition:** A branch is a parallel version of a repository. It is contained within the repository, but does not affect the primary or main branch allowing you to work freely without disrupting the "live" version. When you've made the changes you want to make, you can merge your branch back into the main branch to publish your changes.
    ####
    **Example:**
    ![Branch Ex](http://jlord.us/git-it/assets/imgs/branches.png)

- ### Commit
  * **Definition:** A commit, or "revision", is an individual change to a file (or set of files). When you make a commit to save your work, Git creates a unique ID (a.k.a. the "SHA" or "hash") that allows you to keep record of the specific changes committed along with who made them and when. Commits usually contain a commit message which is a brief description of what changes were made.
    ####
    **Example:**
    ![Commit Ex](https://guides.github.com/activities/hello-world/commit.png)

- ### Merge
  * **Definition:** Merging takes the changes from one branch (in the same repository or from a fork), and applies them into another. This often happens as a "pull request" (which can be thought of as a request to merge), or via the command line. A merge can be done through a pull request via the GitHub.com web interface if there are no conflicting changes, or can always be done via the command line.
    ####
    **Example:**
    ![Merge Ex](https://www.gitcolony.com/img/merge.png)

- ### Checkout
  * **Definition:** You can use `git checkout` on the command line to create a new branch, change your current working branch to a different branch, or even to switch to a different version of a file from a different branch with `git checkout [branchname] [path to file]`. The "checkout" action updates all or part of the working tree with a tree object or blob from the object database, and updates the index and **HEAD** if the whole working tree is pointing to a new branch.
    ####
    **Example:**
    ![Checkout Ex](https://marklodato.github.io/visual-git-guide/checkout-files.svg)

- ### Push
  * **Definition:** To push means to send your committed changes to a remote repository on GitHub.com. For instance, if you change something locally, you can push those changes so that others may access them.
    ####
    **Example:**
    ![Push Ex](https://backlog.com/app/themes/backlog-child/assets/img/guides/git/basics/syncing_repositories_001.png)

- ### Pull
  * **Definition:** Pull refers to when you are fetching in changes and merging them. For instance, if someone has edited the remote file you're both working on, you'll want to pull in those changes to your local copy so that it's up to date. See also fetch.
    ####
    **Example:**
    ![Pull Ex](https://i.ytimg.com/vi/0nqJKEh3YCc/maxresdefault.jpg)

- ### Remote Add / Remove / Show
  * **Remote Add:** will create a new connection record to a remote repository. After adding a remote, you'll be able to use as a convenient shortcut for in other Git commands.

  * **Remote Remove:** Use the `git remote rm` command to remove a remote URL from your repository.

  * **Remote Show:** Shows URLs of remote repositories when listing your current remote connections. By default, listing remote repositories only shows you their shortnames (e.g. "origin"). Using the `-v` option, you will also see the remote's URLs in listings.
    ####
    **Example:**
    ![Remote Ex](https://i.ytimg.com/vi/7jG1Bo84SGc/maxresdefault.jpg)

- ### Status
  * **Definition:** A visual representation within a pull request that your commits meet the conditions set for the repository you're contributing to.
    ####
    **Example:**
    ![Push Ex](https://d1jnx9ba8s6j9r.cloudfront.net/blog/wp-content/uploads/2018/07/15-1.png)

- ### Master Branch
  * **Definition:** The default branch in many Git repositories. By default, when you create a new Git repository on the command line a branch called `master` is created. Many tools now use an alternative name for the default branch. For example, when you create a new repository on GitHub the default branch is called `main`.
    ####
    **Example:**
    ![Push Ex](https://www.nobledesktop.com/image/gitresources/git-branches-merge.png)

branch_name: refs/heads/main


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## 2.4.2 (2021-09-09)

### Bug Fixes

* **spacers:** remove inherit margin so we don't get inconsistent gutters ([e30c78f](https://github.com/Bedrock-Layouts/Bedrock/commit/e30c78f76eae5bbfd49e61df1cd479501ae0486b))

## 2.4.1 (2021-08-31)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

# [2.4.0](https://github.com/Bedrock-Layouts/Bedrock/compare/@bedrock-layout/spacing-constants@2.3.1<EMAIL_ADDRESS>(2021-08-26)

### Features

* **spacing-constants:** export spacing-properties.css ([eb6ae72](https://github.com/Bedrock-Layouts/Bedrock/commit/eb6ae72a50e4c88d5d0890731795a3884cb3fe60))

## 2.3.1 (2021-08-26)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

# [2.3.0](https://github.com/Bedrock-Layouts/Bedrock/compare/@bedrock-layout/spacing-constants@2.2.5<EMAIL_ADDRESS>(2021-07-02)

### Features

* **center:** add size options to maxWidth prop of center ([a66f2f4](https://github.com/Bedrock-Layouts/Bedrock/commit/a66f2f4cea4102a866153bbaba1105615cd94afa))
* **grid:** add size options for grid minItemWidth ([78e7d87](https://github.com/Bedrock-Layouts/Bedrock/commit/78e7d87c113f1fd31b011749a5fecfc1a04b0748))
* **spacing-constants:** add a standard sizes option ([b139445](https://github.com/Bedrock-Layouts/Bedrock/commit/b13944504df089d453a631e7191dc9aa9c0347c7))

## 2.2.5 (2021-06-16)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

## 2.2.4 (2021-06-16)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

## 2.2.3 (2021-06-16)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

## 2.2.2 (2021-06-16)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

## [2.2.1](https://github.com/Bedrock-Layouts/Bedrock/compare/@bedrock-layout/spacing-constants@2.2.0<EMAIL_ADDRESS>(2021-05-26)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

# [2.2.0](https://github.com/Bedrock-Layouts/Bedrock/compare/@bedrock-layout/spacing-constants@2.1.2<EMAIL_ADDRESS>(2021-05-21)

### Features

* **spacing-constants:** update to accept space as a key on the theme ([e037b74](https://github.com/Bedrock-Layouts/Bedrock/commit/e037b74166da8ad0fa02f69e1d6bbe45824b1163)), closes [#542](https://github.com/Bedrock-Layouts/Bedrock/issues/542)

## [2.1.2](https://github.com/Bedrock-Layouts/Bedrock/compare/@bedrock-layout/spacing-constants@2.1.1<EMAIL_ADDRESS>(2021-05-17)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

## [2.1.1](https://github.com/Bedrock-Layouts/Bedrock/compare/@bedrock-layout/spacing-constants@2.1.0<EMAIL_ADDRESS>(2021-05-15)

**Note:** Version bump only for package @bedrock-layout/spacing-constants

# [2.1.0](https://github.com/Bedrock-Layouts/Bedrock/compare/@bedrock-layout/spacing-constants@2.0.0<EMAIL_ADDRESS>(2021-04-16)

### Features

* **spacing-constants:** remove unneeded functions/types ([bc83b93](https://github.com/Bedrock-Layouts/Bedrock/commit/bc83b934aa60eee143cecc9ad582a08eee28f691))


text:
# Collected Notes - Static Site Template with Next.js

This template is based on the Next.js JavaScript framework, and allows you to build a static website that can be updated automatically when notes are added or updated on your Collected Notes account.

## Features

- **Incremental Regeneration** - Deploy once and get incremental updates on your site everytime you create or update notes.
- **Dark Mode Support** - Detect from system preference and per-site support user preference.
- **Search** - Search between all of your notes.
- **Links on the note** - List all the links used at the bottom of each note.
- **Easy to customize** - Create a new repo based on this one and start customizing the look & feel.

## How to create your static website

### Requirements

- A [Collected Notes](https://collectednotes.com/blog/premium) premium account.
- A [Vercel](https://vercel.com) account.

## Step 1: Create your deployment

Make sure you have created a Collected Notes premium account. Then go to your site settings and click on “Create static website” it should take you to the [static deployments page](https://collectednotes.com/sites/static).

**Click on the vercel button:**

[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/import/git?s=https%3A%2F%2Fgithub.com%2FCollected-Notes%2Fstatic-template-nextjs&env=CN_TOKEN,CN_EMAIL,CN_SITE_PATH&envDescription=These%20variables%2C%20are%20required%20to%20read%20your%20site%20data%20from%20the%20Collected%20Notes%20API.&envLink=https%3A%2F%2Fcollectednotes.com%2Faccounts%2Fme%2Ftoken)

Follow the steps. When prompted to enter your environmental variables use the ones that show up on the [static deployments page](https://collectednotes.com/sites/static).

These environment variables are:

- `CN_TOKEN` - Your Collected Notes API token, get it going to https://collectednotes.com/accounts/me/token (needs a Premium account).
- `CN_EMAIL` - The email address you are using for Collected Notes.
- `CN_SITE_PATH` - The path of your site in Collected Notes (e.g. for https://collectednotes.com/blog use `blog`).

---

## Customize your static website

If you want to customize the design of your static website, you can use this repository as a quick starter, in that case go to this URL https://github.com/Collected-Notes/static-template-nextjs/ and clone it.

Once you have the repo, you can start editing the files, below you can find more documentation on how the stack works:

### Stack

These are the main technologies used to build the project

- [TypeScript](https://www.typescriptlang.org)
- [React.js](https://reactjs.org)
- [Next.js](https://nextjs.org)
- [TailwindCSS](https://tailwindcss.com)
- [SWR](https://swr.vercel.app)
- [React Icons](https://react-icons.github.io/react-icons/)
- [useDarkMode](https://github.com/donavon/use-dark-mode)

### File Structure

The code is inside two main folders

- `public`
- `src`

Inside `public` there is a single `dark-mode.js`, this file is loaded first and avoid a flash of different styles between the HTML generated and the correct color schema.

Inside `src` you can find the `style.css` with global styles and `types.d.ts` with the types the different pages and layouts uses.

Then, there are more folders inside `src`

- `component` - Hre live the few reusable components, all in TypeScript and using CSS Modules with Tailwind `@apply` directive to style them.
- `layouts` - Here you can edit the layouts of the three different type of pages (_article_, _home_ and _search_), they are also in TypeScript and CSS Modules with Tailwind.
- `pages` - Pages import the layouts and are in charge of fetching the required data for each one, inside this folder you can find a custom API endpoint used to support the search feature.
- `queries` - Here there is a single custom Hook built on top of SWR to request the `/api/search` endpoint.

repository: pazguille/static-blog-nextjs

repo_name: pazguille/static-blog-nextjs


text:
+++
title = "Connections between parallel and serial combinations of comb filters and feedback delay networks"
date = 2012-01-01
authors = ["Sebastian J Schlecht", "Emanuël A P Habets"]
publication_types = ["1"]
abstract = "Comb filters composed in a parallel or a serial way are a popular part of delay-line based artificial reverberators. Because the analysis of a complex comb filter structure can be tedious, there is a need for transforming such a structure into a compact and general representation. For this a transformation into the feedback delay network (FDN) filter structure is proposed as it is a general and well established framework to investigate the acoustic properties of the filter and therefore allows to compare different approaches. Index Terms ?? comb filter, feedback delay network, artificial reverberation"
selected = false
publication = "*International Workshop on Acoustic Signal Enhancement (IWAENC)*"
url_pdf = "http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6309430&tag=1"
+++


text:
# FastText Serving

FastText Serving is a simple and efficient serving system for [fastText](https://fasttext.cc) models. Inspired by TensorFlow Serving, it provides the missing piece in the microservice puzzle to connect your business logic with basic Natural Language Processing (NLP). The idea of this project is to provide an elegant and reusable implementation for managing several fastText models, allowing to run concurrent multi model predictions. The API of the service is based on gRPC to reduce network latency and deliver higher throughput. For instance, you can run millions of predictions in around one second using just a single CPU.

The service has been developed in Python, making use of Facebook's fastText library for running predictions over text pieces (words, sentences, paragraphs, etc.). The fastText API is used through the Python bindings provided in the official project. Clients of the service can boost their performance by sending multiple sentences grouped in batches within the same request as the fastText library is compiled as a binary.

Serving models are determined by reading the contents of a [configuration file](sample/config.yaml). These models are cached in memory depending on the amount of memory available and the size of the model. Every request is dispatched to the model specified in the body of that request. In addition, models are reloaded when a newer version is published or the file contents are changed in disk, thanks to the [watchdog](https://github.com/gorakhargosh/watchdog) library.

## Features

These are the most interesting features of this project:

- Concurrent management and serving of different models
- Model versioning, allowing A/B test with concurrent requests to different versions
- Hot model serving, loading the new model as soon as a new version is detected in the storage
- Both bag of words and skip-gram models are supported
- gRPC API

## Quick Start

```bash
# Clone the repository
git clone https://github.com/nielsen-oss/fasttext-serving
cd fasttext-serving

# Build the Docker image
IMAGE_NAME=fasttext-serving
docker image build -t IMAGE_NAME .

# Start serving some example models
docker run -p 50051:50051 \
  -v ${PWD}/sample/models:/models \
  -v ${PWD}/sample/config.yaml:/etc/fts/config.yaml \
  -e SERVICE_CONFIG_PATH=/etc/fts/config.yaml \
  IMAGE_NAME

# You can download pretrained models from fasttext webpage
# https://fasttext.cc/docs/en/supervised-models.html
# Do not forget to include the model in the models section of the config
wget https://dl.fbaipublicfiles.com/fasttext/supervised-models/dbpedia.ftz -P sample/models/dbpedia/1/

# Install requirements
pip3 install -r requirements.txt

# Compile protocol buffers (required by the client)
pip3 install .

# Make predictions using the example client
python3 sample/client.py
```

### API

The gRPC API exposes a set of methods for performing model management and predictions with fastText. More specifically, the service provides this functionalities:

  - Classify a sentence
  - Get the words vectors of a set of words
  - Get currently loaded models
  - Load a list of models
  - Reload the models in the configuration file
  - Get the status of a given model:
    - *UNKNOWN*: The model is not defined in the configuration file
    - *LOADED*: The model is cached in memory and ready to make predictions
    - *AVAILABLE*: The model is defined but not loaded, due to resource constraints
    - *FAILED*: The model is not loaded due to a different internal error

The complete specification can be found in the protocol buffer definition in the [protos](protos) directory.

## Troubleshooting

  * Newer versions of the model are not loaded.

    Check that the model has the extension .ftz or .bin and the path where the file has been uploaded.
    Also review your [config file](sample/config.yaml) to check that the model is listed in the *models* section

  * Predictions are too slow.

    Send all the predictions to the same model in bigger batches.
    Increase the maximum number of concurrent workers in the [service configuration](sample/config.yaml).

## Contact

You can open an issue in this project of just email your questions or comments to [Francisco<EMAIL_ADDRESS>or [Javier<EMAIL_ADDRESS>
## Contribute

Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

We recommend you to work in an isolated virtual environment:

```
git clone https://github.com/nielsen-oss/fasttext-serving
cd fasttext-serving
python3 -m venv venv
source venv/bin/activate
export SERVICE_CONFIG_PATH="sample/config.yaml"
python3 -m fts
```

And do not forget to pass the tests and add yours:

```
python3 test/test_suite.py
```

## License

This project is released under the terms of the [Apache 2.0 License](LICENSE).

## Acknowledgements

Big thanks to these third-party projects used by fastText Serving:

  - [fastText](https://fasttext.cc)
  - [grpc](https://github.com/grpc/grpc)
  - [watchdog](https://github.com/gorakhargosh/watchdog)
  - [PyYAML](https://github.com/yaml/pyyaml)

repository: nielsen-oss/fasttext-serving

gha_language: Python

repo_name: nielsen-oss/fasttext-serving


text:
nodejs-module-webos-sysbus
==========================

Summary
-------
A module for nodejs that allows Javascript access to the Open webOS system bus

How to Build on Linux
=====================

## Dependencies

Below are the tools and libraries (and their minimum versions) required to build
_nodejs-module-webos-sysbus_:

* cmake (version required by webosose/cmake-modules-webos)
* g++ 4.6.3
* glib-2.0 2.32.1
* make (any version)
* webosose/cmake-modules-webos 1.0.0 RC3
* webosose/luna-service2 3.0.0
* webosose/nodejs 0.4.12-0webos3
* pkg-config 0.26

## Building

Once you have downloaded the source, enter the following to build it (after
changing into the directory under which it was downloaded):

    $ mkdir BUILD
    $ cd BUILD
    $ cmake ..
    $ make
    $ sudo make install

The directory under which the files are installed defaults to `/usr/local/webos`.
You can install them elsewhere by supplying a value for `WEBOS_INSTALL_ROOT`
when invoking `cmake`. For example:

    $ cmake -D WEBOS_INSTALL_ROOT:PATH=$HOME/projects/webosose ..
    $ make
    $ make install

will install the files in subdirectories of `$HOME/projects/webosose`.

Specifying `WEBOS_INSTALL_ROOT` also causes `pkg-config` to look in that tree
first before searching the standard locations. You can specify additional
directories to be searched prior to this one by setting the `PKG_CONFIG_PATH`
environment variable.

If not specified, `WEBOS_INSTALL_ROOT` defaults to `/usr/local/webos`.

To configure for a debug build, enter:

    $ cmake -D CMAKE_BUILD_TYPE:STRING=Debug ..

To see a list of the make targets that `cmake` has generated, enter:

    $ make help

## Uninstalling

From the directory where you originally ran `make install`, enter:

    $ [sudo] make uninstall

You will need to use `sudo` if you did not specify `WEBOS_INSTALL_ROOT`.

Usage Notes
===========

*Example client (see ./src/test/ls2_app_test.js for details)*
```
    var palmbus = require('palmbus');
    palmbus.setAppId("com.webos.nodeclient.example");

    function responseArrived(message) {
        console.log("responseArrived[" + message.responseToken() + "]:" + message.payload());
    }

    console.log("creating ls2 handle object");

    var h = new palmbus.Handle("com.webos.nodeclient.example");
    var params = {msg: "Hi there"};
    var request = h.call("palm://com.webos.nodeservice.example/test", JSON.stringify(params));
    request.addListener('response', responseArrived);
```

*Example service (see ./src/test/js_app_service_node.js for details)*
```
    var palmbus = require('palmbus');
    palmbus.setAppId("com.webos.nodeservice.example");

    console.log("creating example javascript service");

    function testCallback (message) {
        console.log("payload in test call: '" + message.payload() + "'");
        var r = {msg: "echo request: " + message.payload()};
        message.respond(JSON.stringify(r));
    }

    function requestArrived(message) {
        console.log("requestArrived");
        switch(message.method()) {
        case "test":
            testCallback(message);
            break;
        }
    }

    var h = new palmbus.Handle("com.webos.nodeservice.example");
    h.registerMethod("/", "test")
    h.addListener('request', requestArrived);
```

## Function, Event, Object, and Method Reference

The following section lists the functions and objects that _nodejs-module-webos-sysbus_ adds, what methods
you can call on those objects and what events those objects emit.

### Functions

#### setAppId(appId)

This function sets application ID for Luna services registered in this JS application.
Application ID allows to enforce application-based LS2 security restrictions for executed
Node.js service. This ID should be set in service bootstrap code.

### Handle object

#### Handle(serviceName, [publicBus])

Constructor function used to create a new LS2 service bus object.

Parameters:

- **serviceName** - name of a service to register
- **publicBus [deprecated][optional]** - deprecated argument. LS2 public/private buses separation
is obsolete and use of separate buses is discouraged. If this argument is not passed -
registered service will use security restrictions associated with application ID set
using _**setAppId**_ function.
When specified this argument should be true for services registered on both the public and
private buses, or false for private bus only services.

An object created with palmbus.Handle has the following methods:

#### call(serviceNameAndMethod, methodParameters)
#### watch(serviceNameAndMethod, methodParameters)
#### subscribe(serviceNameAndMethod, methodParameters)

Calls the named service and method, passing the methodParameters string as the
message payload. Usually this is a JSON encoded object, but this method does not
do the encoding for you. Returns a `Call` object that is the source of events and
object to make method calls related to this call.

See the section on garbage collection for an explanation
of the difference between call, watch and subscribe. When in doubt, use call.

#### registerMethod(category, method)

Registers a category and method with the bus. Note that _nodejs-module-webos-sysbus_ does
not provide any mechanism for method-specific dispatch. The event listener
attached to the handle is responsible for using the category() and method()
methods of the message object passed as the first parameter to dispatch the
request to an appropriate handler.

#### subscriptionAdd(key, message)

Enable a message to be used as a subscription. See the Luna Service Library
documentation for a more detailed discussion of subscriptions.

### Handle events

#### 'cancel' event

The 'cancel' event is emitted from a Handle object when a message sent or received
via that Handle is canceled. The canceled message is passed as the single parameter
to any event listener.

#### 'request' event

The 'request' event is emitted from a Handle object when a method registered on
that handle is invoked by the bus. The message that invoked the method is passed
as the single parameter to any event listener. The category() and method() methods
of the message object can be used to dispatch the request to an appropriate handler.

#### 'response' event

The 'response' event is emitted by a Call object when a response to that call is
received. The message that was received is passed as the single parameter to any
event listener.

### Call object

#### cancel()

Use to cancel a call to prevent any further responses and release the resources
needed for the call.

#### setResponseTimeout(timeout_ms)

Sets timeout for a method call. The call will be canceled if no reply
is received after the timeout_ms milliseconds.

### Message object

This object cannot be constructed from JavaScript, but is passed to various events.
A Message object has the following methods:

#### respond(responseString)

Responds to a message. The response string is expected to be a JSON object, but
this method does not do the encoding.

#### payload()

Returns a string containing the payload for this message. This is usually a JSON
encoded object, but this method does not decode it for you.

#### method()

Returns a string describing the method used to send this message.

#### category()

Returns the category for this message.

#### applicationID()

Returns a string containing the applicationID, if any, of the sender of this
message.

#### senderServiceName()

Returns a string containing the service bus name, if any, of the sender of this
message.

#### sender()

Returns the sender of this message.

#### uniqueToken()

Returns the unique token for this message.

#### token()

Returns the token for this message.

#### responseToken()

Returns the response token for this message.

#### kind()

Returns the kind for this message.

#### isSubscription()

Returns true if this message is a subscription.

#### print()

Prints the contents of a message to the terminal.

## Garbage Collection

As long as they are in use for registered methods or calls, Handle objects keep
a reference to themselves and will not be garbage collected. Any event listeners
attached to them will also be referenced and not collected.

Since there is no way to unregister a method, any handle used to register a
service on the bus with registerMethod will never be collected.

In the call case, as long as a call has been made and the expected number of
responses have not yet arrived the call and handle are protected. Such a system
could lead to serious resource use if over time a user of _nodejs-module-webos-sysbus_
creates a lot of calls with pending responses.

In order to minimize such resource use there are three different call producing
methods on Handle; call, watch and subscribe.

Call expects only one response. As soon as it arrives both the call self-reference
and the call's reference to the handle are released. Call also uses the LS2 API
function LSCallOneReply on the hope that it is more efficient for this case.

Watch expects two responses. After the second response arrives the call
self-reference and the call's reference to the handle are released.

Subscribe allows for any number of responses. Unless canceled, the call
self-reference and the call's reference to the handle will never be released.

The only exception to the above cases is when an error is returned from the bus.
In that case the call self-reference and the call's reference to the handle are
released immediately.

# Copyright and License Information

Copyright (c) 2010-2018 LG Electronics, Inc.

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

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

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

SPDX-License-Identifier: Apache-2.0

repository: webosce/nodejs-module-webos-sysbus

branch_name: refs/heads/webosce

repo_name: webosce/nodejs-module-webos-sysbus


text:
---
layout: post
title:  "WPF Animations and the Async/Await Model"
date:   2015-09-19 17:00:00 +1300
tags: c# wpf threading
excerpt_separator: <!--more-->
---
I recently encountered this little gotcha at work, and thought it could benefit others, so... here you go.

<!--more-->

When you start an animation in WPF from code and then make an awaitable call, the animation fails to show until the call is complete. Why is this?

As an example, suppose we have this click handler on a button:

```c#
private async void _Button_Clicked(object sender, EventArgs e)
{
    firstAnimation.Begin();

    await _SomeAsyncCall();

    secondAnimation.Begin();
}

private Task _SomeAsyncCall()
{
    Thread.Sleep(5000);
}
```

Let's test it! When we click the button, we see... nothing. For five seconds anyways. Then we'll see both animations happen together (or if the first animation was less than the async call, it'll jump to the end or you just won't see it).

The issue here lies in the Dispatcher and how the async/await model tries to minimize threads. We all know that the async/await model runs tasks asynchronously, but what is less commonly known is that it attempts to do so on the thread from which it's called. In this case, we're making the async call from the UI thread. And since animations have such low priority, they're pushed aside to allow the call to complete first.

Here's the sequence of events occurring in this scenario:

1. The button is clicked, calling the handler method _Button_Clicked().
1. The first animation begins.
    - Internal to the animation, a management task is sent to the Dispatcher to handle the animation. The Dispatcher must complete its current task before moving on to the next one, so the task gets placed in a queue.
1. The async call occurs.
    - A task is sent to the Dispatcher to handle the call. Just as before, the task is placed in the Dispatcher's queue.
    - This time, we have an await, so the method actually ends here. The rest of it is part of a task continuation (Task.ContinueWith()). The continuation is treated as another task and will be placed in the queue once this task completes.
1. Since the method has ended, the Dispatcher is now free to select the next task. It does this by priority, and since the animation has an ultra-low priority, the async call wins.
1. The async call completes, but there is a continuation on the task. This is placed in the queue.
1. The Dispatcher makes another selection, which is the continuation, further deferring the animation.
1. The second animation begins, placing a management task in the queue, ending the continuation task.
1. The Dispatcher is now free again to make another selection, and it can handle both animations normally.

Now that we know what's going on, how can we fix this? The problem seems to be that the async call is being performed on the UI thread, so we need to move it to its own thread. To do this, we must abandon the glorious async and await keywords and manually implement tasks.

```c#
private void _Button_Clicked(object sender, EventArgs e)
{
    firstAnimation.Begin();

    Task.Run(_SomeAsyncCall)
        .ContinueWith(result => secondAnimation.Begin());
}

private void _Dispatch(Action action)
{
    if (Dispatcher.CheckAccess())
        action();
    else
        Dispatcher.Invoke(action);
}
```

By using the `Task.Run()` method, we've forced the call to `_SomeAsyncCall()` to be performed on a second thread. This means that the Dispatcher can use the UI thread to run the first animation. Once the async call ends, the continuation picks up on the thread we created, and the second animation can begin.

We need to be careful here because the animation must run on the UI thread. In order to ensure that it does, we have to verify that we have use the `Dispatcher.CheckAccess()` method. If we have access, we just run it; otherwise, we have to pass it to `Dispatcher.Invoke()` and let the Dispatcher run it.

Now, when we run the application and click the button, we see the first animation, then after five seconds, we see the second animation run, just as we wanted.

repository: gregsdennis/coding-for-smarties

gha_language: HTML

repo_name: gregsdennis/coding-for-smarties


text:
# glide-stripvcs

This is a plugin for [Glide](https://github.com/Masterminds/glide) that strings VCS data from packages in the `vendor/` folder.

## Usage

1. Install Glide and this application (`go get github.com/mattfarina/glide-stripvcs`).
2. Run `glide up` to generate a `glide.lock` file and get the vendor tree set.
3. Run `glide stripvcs` to remove the VCS data from the packages in the `vendor/` folder.

repository: mattfarina/glide-stripvcs

repo_name: mattfarina/glide-stripvcs


text:
# Course Management Rest API

## About

A Spring boot application for managing back-end for course management.

This practice application provides full CRUD functionality for topics and courses (many to one) and entity relationships using Spring Data JPA and Apache Derby as back-end.

## Technology Stack

1. Developed using Spring boot
1. Back-end managed by Spring Data JPA
1. Back-end provided by Apache Derby

## Developer

-  Adnan Hakim [github.com/adnanhakim](https://github.com/adnanhakim)

## List of APIs

- `GET` `/topics`: Get all topics
- `GET` `/topics/{topicId}`: Get topic by id
- `POST` `/topics`: Add new topic
- `PUT` `/topics/{topicId}`: Update topic by id
- `DELETE` `/topics/{topicId}`: Delete topic by id
- `GET` `/topics/{topicId}/courses`: Get all courses by topic id
- `GET` `/topics/{topicId}/courses/{courseId}`: Get course by id
- `POST` `/topics/{topicId}/courses`: Add new course
- `PUT` `/topics/{topicId}/courses/{courseId}`: Update course by id
- `DELETE` `/topics/{topicId}/courses/{courseId}`: Delete course by id

## Build

-  Clean and install project
    ```shell script
   mvnw clean install
   ```
-  Run spring application
    ```shell script
   java -jar target/course-api-0.0.1-SNAPSHOT.jar
   ```

## MIT LICENSE

> Copyright (c) 2020 Adnan Hakim
>
> 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.
>
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 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: adnanhakim/spring-course-rest-api

repo_name: adnanhakim/spring-course-rest-api


text:
Be productive without leaving your keyboard

Try it online at https://pomoday.vercel.app

---

- [What is Pomoday?](#what-is-pomoday)
- [Features](#features)
- [Usage and Installation](#usage-and-installation)
    - [Online version](#online-version)
    - [Self-hosted](#self-hosted-version)
- [Development](#development)
- [Syncing across devices](#syncing-across-devices)
- [Similar Projects](#similar-projects)
- [Backers and Sponsors](#backers-and-sponsors)
- [License](#license)

---

## What is Pomoday?

![](screenshot.png)

Pomoday is an easy to use, yet powerful and flexible web-based task management software that you can use with just a keyboard.

It's flexible and doesn't tie with any productivity methodologies, that means, you
can customize and use it in anyway you want, try implementing yourself a GTD or Kanban or
Pomodoro workflow with it.

## Features

1. Task management (of course)
2. Keyboard only workflow
3. Built-in time tracker
4. Activities log to get an overview on how you spent your day
5. Dark mode
6. (A lot coming...)

## Usage and Installation

There are two ways to use Pomoday:

### Online version

You can use the online version at https://pomoday.app

### Self-hosted version

Please make sure you have `node` and `npm` installed on your machine.

To host Pomoday locally or on your own server:

1. Clone this repository
  ```
  git clone https://github.com/huytd/pomoday-v2
  ```
2. Install the dependencies
  ```
  npm install
  ```
3. Build
  ```
  npm run dist
  ```
4. Now you can deploy the `dist` folder anywhere, just like a static web page

It's recommended to deploy it to [now.sh](https://now.sh), because it's easy:

```
$ cd dist
$ now
```

## Development

To run it locally during development, use:

```
npm run dev
```

## Docker

This repo includes a `Dockerfile` and a `docker-compose.yml` to easily run the project in a container. Just run the following two commands to build the container image and start it up:

```
$ docker-compose build
$ docker-compose up -d
```

## Syncing across devices

To sync the data across devices, you'll need to implement your own backend, please see [Backend API Specification](https://github.com/huytd/pomoday-v2/wiki/Pomoday-Backend-API-Specification) for the details.

To use https://pomoday.app with your own backend, there's a `login` command in the app, you'll be able to put your backend API URL there.

You can also check the list of [3rd party backend](https://github.com/huytd/pomoday-v2/wiki/Backend-(for-data-synchronize)) for self-hosted options.

## Similar Projects

- [taskbook](https://github.com/klaussinani/taskbook): This is an awesome task management application that actually works, and works very well for everyone who likes to live in a command line. Pomoday was also heavily inspired by Taskbook, as you can see from the UI and the keyboard-only command interfaces.

## Backers and Sponsors

I would like to give a special thanks to all of the advisors and backers who sponsored this project since day-zero.

|  |  |  |  |  |  |  |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
|[**imhuyqn**](https://github.com/imhuyqn)|[**ledongthuc**](https://github.com/ledongthuc)|[**trungfinity**](https://github.com/trungfinity)|[**thaod**](https://github.com/thaod)|[**mquy**](https://github.com/mquy)|[**quannt**](https://github.com/quannt)|[**dvkndn**](https://github.com/dvkndn)|

## Contributors

### Code Contributors

This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].

### Financial Contributors

Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/pomoday-project/contribute)]

#### Individuals

#### Organizations

Support this project with your organization.  [[Contribute](https://opencollective.com/pomoday-project/contribute)]

## License

Pomoday is published under BSD 3-Clause license.


text:
# Flask-rest
### An simple rest api built in python
**Prequisites:**

1.  Install python 3 [Get it here](https://www.python.org/downloads/). Check if it installed correctly by typing (cmd/terminal): `python3` you should get a python repl. type `exit()` to leave the repl.
2.   Install pip:
     * Mac: comes with python3. should be able to check by typing `pip3 --version` from terminal
     * Linux: both python 2 and 3 come by default on newer linux. pip may need to be installed via `sudo apt-get install python3-pip` and additional libraries may also be needed `sudo apt-get install python3-dev`s
     * Windows:
     * Pip may need to be upgraded `pip3 install --upgrade pip` (Can be done once you are in a virtual environment)
3.  Install any text editor:
    * [Pycharm Community Edition](https://www.jetbrains.com/pycharm/), [Sublime Text](https://dbader.org/blog/setting-up-sublime-text-for-python-development), and [Atom](http://www.marinamele.com/install-and-configure-atom-editor-for-python) are all great for this. **I highly recommend Atom or PyCharm for people who don't like configuring an editor.**
    * If you use atom, all of the extensions are optional. It supports python and autocompletions out of the box. If you follow the installation instructions for linter and flake8, make sure you are not in an virtual environment, and use the location for your flake8 installation (find with `which flake8` for Linux/Mac) rather than for the author's. If on Windows, use the atom installer ctrl+shift+p and type install packages. From that interface you can install all of your packages.

**Install Project**

1.  from the command line or git gui, clone the repository: https://github.com/full-stakk/flask-rest.git
2.  cd into the directory from command line
3.  Create a virtual environment: `python3 -m venv env`
4.  Use venv:
    * Mac/Linux: `source env/bin/activate` (to leave a virtual environment type `deactivate`)
5.  Install dependencies into virtual environment:
    * Mac/Linux: `pip install -r requirements.txt`
    * `pip freeze` should show a list of dependencies installed
6.  Run the program:
    * from command line (after you activate env) type `python3 app.py`
    * from the browser go to localhost:8000

Enjoy...

repository: brewencoded/flask-rest

repo_name: brewencoded/flask-rest


text:
# resolve-pathname [![Travis][build-badge]][build] [![npm package][npm-badge]][npm]

[build-badge]: https://img.shields.io/travis/mjackson/resolve-pathname/master.svg?style=flat-square
[build]: https://travis-ci.org/mjackson/resolve-pathname
[npm-badge]: https://img.shields.io/npm/v/resolve-pathname.svg?style=flat-square
[npm]: https://www.npmjs.org/package/resolve-pathname

[resolve-pathname](https://www.npmjs.com/package/resolve-pathname) resolves URL pathnames identical to the way browsers resolve the pathname of an `<a href>` value. The goals are:

- 100% compatibility with browser pathname resolution
- Pure JavaScript implementation (no DOM dependency)

## Installation

Using [npm](https://www.npmjs.com/):

    $ npm install --save resolve-pathname

Then, use as you would anything else:

```js
// using ES6 modules
import resolvePathname from 'resolve-pathname';

// using CommonJS modules
var resolvePathname = require('resolve-pathname');
```

The UMD build is also available on [unpkg](https://unpkg.com):

```html
<script src="https://unpkg.com/resolve-pathname"></script>
```

You can find the library on `window.resolvePathname`.

## Usage

```js
import resolvePathname from 'resolve-pathname';

// Simply pass the pathname you'd like to resolve. Second
// argument is the path we're coming from, or the current
// pathname. It defaults to "/".
resolvePathname('about', '/company/jobs'); // /company/about
resolvePathname('../jobs', '/company/team/ceo'); // /company/jobs
resolvePathname('about'); // /about
resolvePathname('/about'); // /about

// Index paths (with a trailing slash) are also supported and
// work the same way as browsers.
resolvePathname('about', '/company/info/'); // /company/info/about

// In browsers, it's easy to resolve a URL pathname relative to
// the current page. Just use window.location! e.g. if
// window.location.pathname == '/company/team/ceo' then
resolvePathname('cto', window.location.pathname); // /company/team/cto
resolvePathname('../jobs', window.location.pathname); // /company/jobs
```

## Prior Work

- [url.resolve](https://nodejs.org/api/url.html#url_url_resolve_from_to) - node's `url.resolve` implementation for full URLs
- [resolve-url](https://www.npmjs.com/package/resolve-url) - A DOM-dependent implementation of the same algorithm

repository: GenaAiv/portfolio-website

gha_language: JavaScript

repo_name: GenaAiv/portfolio-website


text:
Article 2A (In case UNHCR conducts registration without Government involvement)

Ti=Registration of refugees and asylum-seekers

1.sec=Registration is a fundamental component of international protection. In carrying out its mandate, {_UNHCR} [will conduct/conducts] the registration of refugees and asylum-seekers in the {_country}, subject to the availability of resources and to the Office’s operational needs.

Note=If no Accord de Siege has been signed:

2.sec=[The Government shall at all time grant {_UNHCR} personnel unimpeded access to all refugees, asylum-seekers and other persons of concern to {_UNHCR}.]

=[G/Z/ol/s2]

repository: CommonAccord/Cmacc-Org

gha_language: CSS

repo_name: CommonAccord/Cmacc-Org


text:
[![Build Status](https://travis-ci.org/LUSHDigital/microservice-db-golang.svg?branch=master)](https://travis-ci.org/LUSHDigital/microservice-db-golang)
 [![](https://godoc.org/github.com/LUSHDigital/microservice-db-golang?status.svg)](https://godoc.org/github.com/LUSHDigital/microservice-db-golang)

Lush Digital - Micro Service Database (Golang)
---

A set of database packages for Golang microservices. Best used in conjunction
 with [microservice-core-golang](https://github.com/LUSHDigital/microservice-core-golang)

**NOTE: Requires Go 1.10+**

# Package Contents

### Migrator
Migrator utilises the package `github.com/` for processing time-stamped `.sql`
files to be ran as sequenntial migrations against a database. Currently it
supports the  following databases:
* [CockroachDB](https://www.cockroachlabs.com/product/cockroachdb/)

# Installation
Install the package as normal, or use your preferred vendoring tool:

`go get -u github.com/LUSHDigital/microservice-db-golang`

repository: LUSHDigital/microservice-db-golang

gha_language: Go

repo_name: LUSHDigital/microservice-db-golang


text:
pyCloudAPILib - written by Lans Zhang<EMAIL_ADDRESS>
- Overview
- Changelogs
- Examples
- Note

[Overview]
This python library provides the support for a various of cloud API and gives
an unique interface for application.

Currently, this library support Axeda Platform and Wind River Mashery API manager.

In the context of this library, all machines connected to cloud are deems as
nodes, either a role of server or client.

[Examples]
- benchmark_getsetdata.py
This example code demonstrates how to call get/set function to operate a data
item stored in cloud and benchmark the get/set performance. Type
benchmark_getsetdata.py -h for help.

- config.py
Pre-defined cloud settings for Wind River Axeda server and Mashery API manager.

[Note]
python-requests and ssl modules have a bug on handling SSL URL of mashery API
manager. pyCloudAPILib masks the SSL warning but it essentionally causes a
performance impact. To remove the impact, apply the patch patch/requests-fix-matching-special-URL-for-SSL-certificate.patch
to python-requests module.

Then modify config.py and change the following line
"ssl": False,
to
"ssl": True,

[Changelogs]
2015/03/25: ver 0.0.4
* README cleanup

2015/02/21: ver 0.0.3
* Add node.getHistoricalData() support

2015/02/21: ver 0.0.2
* Remove server.py.
* Code cleanup.
* Enhance benchmark_getsetdata.py.
* Add the API support for Axeda Platform.

2015/02/16: ver 0.0.1
* Initial version, supporting Wind River Mashery API manager for get/set data
item.

repository: TeamValvrave/pyCloundAPILib

repo_name: TeamValvrave/pyCloundAPILib


text:
# Caesar Cipher

## Author
Linda Tonui

## Read ME
This is a java application that implements the Caesar Cipher form of encryption in Java .
 Caesar Cipher is a simple form of encryption in which each letter in the plaintext
  is shifted through the alphabet a number of positions depending on the given
  shift key.

  ## Technologies Used
  - Intelli-J
  - Git
  - Gradle
  - Java

  ## Setup Instructions
   - Clone Repository on your local machine using the link
  - cd into a directory ` CeasarCipher`
  - Open with Intelli-J
 - Open Terminal
 - Run command `gradle compileJava`
 - Navigate `build/classes/java/main`
 - Run the command `java CaesarCipher`

 ## Bugs and Errors
 None Found

# BDD
- Input : word
- Encrypted text: xpse
- Decrypted text: word

- Input:THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
- Encrypted Text : QEB NRFZH YOLTK CLU GRJMP LSBO QEB IXWV ALD
- Decrypted Text : THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG

repository: MemoTonui/CaesarCipher

repo_name: MemoTonui/CaesarCipher


text:
---
layout: post
title: "How a Lazy Pilot Learned to Love Maintaining his Airplane"
description: "I recently have completed a lot of maintenance on my Cessna 177RG"
category:
date: 2019-04-20
cover_image: "./cowloff.jpg"
---

## I recently have completed a lot of maintenance on my Cessna 177RG

I had a professor in college who said "Don't ever buy an airplane". I did not listen to him because I bought into a partnership for a Cessna Cardinal last year. General Aviation aircraft are notorious for being expensive to maintain. The more complex the aircraft, the more expensive it is to maintain. The General Aviation fleet of aircraft are just getting older. According the FAA, the average age of a General Aviation Aircraft is 35 years old.

When I was learning to fly, I don't think I ever even refueled the aircraft I rented. We always had mechanics that did all of our maintenance. Not being the owner of the aircraft, I never thought much about the maintenance of the aircraft outside of knowing the legal requirements for inspections by licensed A&P mechanics.

So whenever our mechanic comes out to work on the plane, I alway try to be there to help him with the maintenance. We recently replaced the oil sump gasket and a cylinder in the engine. Replacing the oil sump gasket required removing the engine from the firewall using a cherry picker. As a pilot, I never thought I would ever slide a new cylinder onto the crankcase of an aircraft engine, but I did a week ago.

**Engine Oil Sump**

**New Cylinder**

## As a Pilot, What are you Allowed to do on your Aircraft

According to Federal Aviation Regulation part 43, a pilot is allowed to do a lot of preventative maintenance. I came across the following FAA document called [Maintenance Aspects of Owning Your Own Aircraft](https://www.faasafety.gov/files/gslac/library/documents/2011/Aug/56398/FAA%20P-8740-15%20Maintenance%20Aspects%20of%20Owning%20Your%20Own%20Aircraft%20[hi-res]%20branded.pdf). The one caveat is that if the aircraft is used for part 121, 127, 129 or 135 operations the pilot cannot do their own maintenance.

Here are some of the things a pilot can do to their aircraft;

* Remove, install, and repair landing gear tires.
* Service landing gear wheel bearings (for example, cleaning and greasing).
* Service landing gear shock struts (for example, adding oil, air, or both).
* Replace defective safety wire or cotter keys.
* Lubricate items not requiring disassembly other than removal of nonstructural items (for example, cover plates,
cowling, and fairings).
* Replenish hydraulic fluid in the hydraulic reservoir.
* Apply preservative or protective material to components where no disassembly of any primary structure or
operating system is involved, and where such coating is not prohibited or contrary to good practices.
* Replace safety belts.
* Replace bulbs, reflectors, and lenses of position and landing lights.
* Replace or clean spark plugs and set spark plug gap clearance.
* Replace any hose connection, except hydraulic connections.
* Replace and service batteries.
* Make simple fabric patches not requiring rib stitching or the removal of structural parts or control surfaces.
(Note: For balloons, this includes making small fabric repairs to envelopes as defined in, and in accordance
with, the balloon manufacturer’s instructions and which do not require load tape repair or replacement.)
* Replace any cowling not requiring removal of the propeller or disconnection of flight controls.

Another important detail hear is to make sure that all maintenance is properly logged in the aircraft's maintenance log book. Each log entry must include a description of the work performed, or references that are acceptable to the administrator. The date the maintenance was completed, and the signature, certificate number and kind of certificate held by the person doing the work.

## The Hard Work Payed Off

I felt quite a bit of satisfaction when we finally got the cowling put back on and the engine fired up for the first time. Here is the video of our first engine start after completing the engine work;


text:
connect.rdns_access
===================

This plugin will evaluate the remote IP address and the remote rDNS hostname
against a set of white and black lists.  The lists are applied in the following
way:

connect.rdns_access.whitelist         (pass)
connect.rdns_access.whitelist_regex   (pass)
connect.rdns_access.blacklist         (block)
connect.rdns_access.blacklist_regex   (block)

Configuration connect.rdns_access.ini
-------------------------------------

General configuration file for this plugin.

* connect.rdns_access.general.deny_msg

  Text to send the user on reject (text).

Configuration connect.rdns_access.whitelist
-------------------------------------------

The whitelist is mostly to counter blacklist entries that match more than
what one would want.  This file should be used for a specific IP address
or rDNS hostnames, one per line, that should bypass blacklist checks.
NOTE: We heavily suggest tailoring blacklist entries to be as accurate as
possible and never using whitelists.  Nevertheless, if you need whitelists,
here they are.

Configuration connect.rdns_access.whitelist_regex
-------------------------------------------------

Does the same thing as the whitelist file, but each line is a regex.
Each line is also anchored for you, meaning '^' + regex + '$' is added for
you.  If you need to get around this restriction, you may use a '.*' at
either the start or the end of your regex.  This should help prevent people
from writing overly permissive rules on accident.

Configuration connect.rdns_access.blacklist
-------------------------------------------

This file should be used for a specific IP address or rDNS hostnames, one
per line, that should fail on connect.

Configuration connect.rdns_access.blacklist_regex
-------------------------------------------------

Does the same thing as the blacklist file, but each line is a regex.
Each line is also anchored for you, meaning '^' + regex + '$' is added for
you.  If you need to get around this restriction, you may use a '.*' at
either the start or the end of your regex.  This should help prevent people
from writing overly permissive rules on accident.