text:
# ForeignKeyBox

<xref:DevZest.Data.Views.ForeignKeyBox> represents a clickable box to display and edit foreign key data, as shown in `AdventureWorksLT.WpfApp` sample:

![image](/images/ForeignKeyBox.jpg)

## Features

* Data binding to display foreign key as lookup data. For example, instead of displaying the `AddressID` foreign key column, the lookup data of `AddressLine1`, `AddressLine2`, `City`, `StateProvince`, `CountryRegion` and `PostalCode` are displayed.
* Provides an clickable icon to clear underlying foreign key data.
* Clicking the <xref:DevZest.Data.Views.ForeignKeyBox> will launch a new view of lookup data, typically a drop-down list as popup window, or a model dialog window, as shown in preceding example.

## Usage

First, add <xref:DevZest.Data.Views.ForeignKeyBox> as row binding via <xref:DevZest.Data.Presenters.BindingFactory.BindToForeignKeyBox*>, as demonstrated in `AdventureWorksLT.WpfApp` sample:

# [C#](#tab/cs)

```csharp
public static RowCompositeBinding<SalesOrderHeaderBox> BindToSalesOrderHeaderBox(this SalesOrderInfo _, bool isNew,
    out RowBinding<ForeignKeyBox> shipToAddressBinding, out RowBinding<ForeignKeyBox> billToAddressBinding)
{
    var result = new RowCompositeBinding<SalesOrderHeaderBox>()
        .AddChild(_.FK_Customer.BindToForeignKeyBox(_.Customer, CustomerBox.RefreshAction), v => v._customer)
        .AddChild(shipToAddressBinding = _.FK_ShipToAddress.BindToForeignKeyBox(_.ShipToAddress, AddressBox.RefreshAction), v => v._shipTo)
        .AddChild(billToAddressBinding = _.FK_BillToAddress.BindToForeignKeyBox(_.BillToAddress, AddressBox.RefreshAction), v => v._billTo)
    ...
}
```

# [VB.Net](#tab/vb)

```vb
Public Function BindToSalesOrderHeaderBox(e As SalesOrderInfo, isNew As Boolean, ByRef shipToAddressBinding As RowBinding(Of ForeignKeyBox),
                                            ByRef billToAddressBinding As RowBinding(Of ForeignKeyBox)) As RowCompositeBinding(Of SalesOrderHeaderBox)
    shipToAddressBinding = e.FK_ShipToAddress.BindToForeignKeyBox(e.ShipToAddress, AddressBox.RefreshAction)
    billToAddressBinding = e.FK_BillToAddress.BindToForeignKeyBox(e.BillToAddress, AddressBox.RefreshAction)
    Dim result = New RowCompositeBinding(Of SalesOrderHeaderBox)() _
        .AddChild(e.FK_Customer.BindToForeignKeyBox(e.Customer, CustomerBox.RefreshAction), Function(v) v._customer) _
        .AddChild(shipToAddressBinding, Function(v) v._shipTo) _
        .AddChild(billToAddressBinding, Function(v) v._billTo) _
        ...
    Return result
End Function
```

***

Second, implement <xref:DevZest.Data.Views.ForeignKeyBox.ILookupService> to provide lookup data for foreign key, as demonstrated in `AdventureWorksLT.WpfApp` sample:

# [C#](#tab/cs)

```csharp
private class Presenter : DataPresenter<SalesOrderInfo>, ForeignKeyBox.ILookupService
{
    ...
    bool ForeignKeyBox.ILookupService.CanLookup(CandidateKey foreignKey)
    {
        if (foreignKey == _.FK_Customer)
            return true;
        else if (foreignKey == _.FK_BillToAddress)
            return true;
        else if (foreignKey == _.FK_ShipToAddress)
            return true;
        else
            return false;
    }

    void ForeignKeyBox.ILookupService.BeginLookup(ForeignKeyBox foreignKeyBox)
    {
        if (foreignKeyBox.ForeignKey == _.FK_Customer)
        {
            var dialogWindow = new CustomerLookupWindow();
            dialogWindow.Show(_ownerWindow, foreignKeyBox, CurrentRow.GetValue(_.CustomerID), _shipToAddressBinding[CurrentRow], _billToAddressBinding[CurrentRow]);
        }
        else if (foreignKeyBox.ForeignKey == _.FK_ShipToAddress || foreignKeyBox.ForeignKey == _.FK_BillToAddress)
            BeginLookupAddress(foreignKeyBox);
        else
            throw new NotSupportedException();
    }

    private void BeginLookupAddress(ForeignKeyBox foreignKeyBox)
    {
        var foreignKey = (Address.PK)foreignKeyBox.ForeignKey;
        if (_addressLookupPopup.FK == foreignKey)
            _addressLookupPopup.IsOpen = false;
        else
        {
            var customerID = CurrentRow.GetValue(_.CustomerID);
            if (customerID.HasValue)
            {
                var addressID = foreignKeyBox.ForeignKey == _.FK_ShipToAddress ? _.ShipToAddressID : _.BillToAddressID;
                _addressLookupPopup.Show(foreignKeyBox, CurrentRow.GetValue(addressID), customerID.Value);
            }
        }
    }
}
```

# [VB.Net](#tab/vb)

```vb
Private Class Presenter
    Inherits DataPresenter(Of SalesOrderInfo)
    Implements ForeignKeyBox.ILookupService
    ...
    Function CanLookup(foreignKey As CandidateKey) As Boolean Implements ForeignKeyBox.ILookupService.CanLookup
        If foreignKey Is Entity.FK_Customer Then
            Return True
        ElseIf foreignKey Is Entity.FK_BillToAddress Then
            Return True
        ElseIf foreignKey Is Entity.FK_ShipToAddress Then
            Return True
        Else
            Return False
        End If
    End Function

    Sub BeginLookup(foreignKeyBox As ForeignKeyBox) Implements ForeignKeyBox.ILookupService.BeginLookup
        If foreignKeyBox.ForeignKey Is Entity.FK_Customer Then
            Dim dialogWindow As New CustomerLookupWindow()
            dialogWindow.Show(_ownerWindow, foreignKeyBox, CurrentRow.GetValue(Entity.CustomerID), _shipToAddressBinding(CurrentRow), _billToAddressBinding(CurrentRow))
        ElseIf foreignKeyBox.ForeignKey Is Entity.FK_ShipToAddress OrElse foreignKeyBox.ForeignKey Is Entity.FK_BillToAddress Then
            BeginLookupAddress(foreignKeyBox)
        Else
            Throw New NotSupportedException()
        End If
    End Sub

    Private Sub BeginLookupAddress(foreignKeyBox As ForeignKeyBox)
        Dim foreignKey As Address.PK = CType(foreignKeyBox.ForeignKey, Address.PK)
        If _addressLookupPopup.FK Is foreignKey Then
            _addressLookupPopup.IsOpen = False
        Else
            Dim customerID = CurrentRow.GetValue(Entity.CustomerID)
            If customerID.HasValue Then
                Dim addressID = If(foreignKeyBox.ForeignKey Is Entity.FK_ShipToAddress, Entity.ShipToAddressID, Entity.BillToAddressID)
                _addressLookupPopup.Show(foreignKeyBox, CurrentRow.GetValue(addressID), customerID.Value)
            End If
        End If
    End Sub
    ...
End Class
```

***

## Implemented Commands

| Command | Instance | Input | Implementation |
|---------|----------|-------|----------------|
| <xref:DevZest.Data.Views.ForeignKeyBox.Commands.ClearValue> | <xref:DevZest.Data.Views.ForeignKeyBox> | Control template. | Clears underlying foreign key data. |

## Customizable Services

* <xref:DevZest.Data.Views.ForeignKeyBox.ICommandService>: Your data presenter can implement this service to change the commands implementation of this class.
* <xref:DevZest.Data.Views.ForeignKeyBox.ILookupService>: There is no default implementation. Your data presenter must implement this interface to lookup data from another view, as shown in preceding example.


text:
# Vanilla JS HTML5 Video Player

Still heavily work in progress :)

![image](https://user-images.githubusercontent.com/2427877/119615699-f9c9e380-bdff-11eb-9a54-f3876ad9138d.png)

## Functionality

- Playback of all browser supported formats
- Toggleable Subtitles/Captions via VTT
- Basic playback controls
- Playback quality controls
- Basic fullscreen capabilities
- Progress and buffering indicator

## Parameters

| Name | Description | Default |
|---|---|---|
| selector | A selector query string pointing to the div the player should be rendered in | '' |
| poster | The relative or absolute URL pointing to the video preview image | '' |
| subtitles | The relative or absolute URL pointing to the video captions VTT file | null |

license: MIT

repository: sabieber/CinematicJS

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: sabieber/CinematicJS


text:
# Enhanced HttpClient

Methanol has a special `HttpClient` that extends the standard one with interesting new features.
Unsurprisingly, the client is named `Methanol`.

## Usage

In addition to [interceptors] and [caching], `Methanol` can apply default properties to your requests.
Think resolving with a base URI, adding default request headers, default timeouts, etc.

```java
var builder = Methanol.newBuilder()
    .cache(...)
    .interceptor(...)
    .userAgent("Will Smith")                     // Custom User-Agent
    .baseUri("https://api.github.com")           // Base URI to resolve requests' URI against
    .defaultHeader("Accept", "application/json") // Default request headers
    .requestTimeout(Duration.ofSeconds(20))      // Default request timeout
    .headersTimeout(Duration.ofSeconds(5))       // Timeout for receiving response headers
    .readTimeout(Duration.ofSeconds(5))          // Timeout for single reads
    .autoAcceptEncoding(true);                   // Transparent response compression, this is true by default

// Continue using as a standard HttpClient.Builder!
var client = builder.executor(...)
    .executor(Executors.newFixedThreadPool(16))
    .connectTimeout(Duration.ofSeconds(30))
    ...
    .build();
```

You can also build from an existing `HttpClient` instance. However, you can't install an `HttpCache`
in such case.

```java
HttpClient prebuiltClient = ...
var client = Methanol.newBuilder(prebuiltClient)
    .interceptor(...)
    .userAgent("Will Smith")
     ...
    .build();

```

!!! tip
    `Methanol` is an `HttpClient`. It implements the same API like `send` & `sendAsync`, which you can
    continue using as usual.

!!! note
    Default properties don't override those the request already has. For instance, a client with a
    default `Accept: text/html` will not override a request's `Accept: application/json`.

### Transparent Compression

If `autoAcceptEncoding` is enabled, the client complements requests with an `Accept-Encoding` header
which accepts all supported encodings (i.e. available [`BodyDecoder`](decompression.md) providers). Additionally,
the response is transparently decompressed according to its `Content-Encoding`.

Since `deflate` & `gzip` are supported out of the box, they're always included in `Accept-Encoding`.
For instance, if [brotli][methanol-brotli] is installed, requests will typically have: `Accept-Encoding: deflate, gzip, br`.
If you want specific encodings to be applied, add `Accept-Encoding` as a default header or explicitly
set one in your request.

=== "Default Header"

    ```java
    // Advertise brotli decompression
    var client = Methanol.newBuilder()
        .defaultHeader("Accept-Encoding", "br")
        .build();
    ```

=== "Request Header"

    ```java
    // Advertise brotli decompression
    var request = MutableRequest.GET(uri)
        .header("Accept-Encoding", "br");
    ```

### MimeBodyPublisher

`Methanol` automatically sets a request's `Content-Type` if it has a [`MimeBodyPublisher`](media_types.md#mimebodypublisher).
If the request already has a `Content-Type`, it's overwritten. This makes sense as a body knows its media type
better than a containing request mistakenly setting a different one.

### Reactive Dispatching

If you like reactive streams, use `Methanol::exchange`, which is like `sendAsync` but returns
`Publisher<HttpResponse<T>>` sources instead.

=== "Without HTTP/2 Push"

    ```java
    var client = Methanol.create();

    var request = MutableRequest.GET("https://http2-push.appspot.com/?nopush");
    var publisher = client.exchange(request, BodyHandlers.ofFile(Path.of("page.html")));

    JdkFlowAdapter.flowPublisherToFlux(publisher)
        .doOnNext(response -> System.out.printf("%s: %s", response, response.body()))
        .blockLast();
    ```

=== "With HTTP/2 Push"

    ```java
    var client = Methanol.create();

    var request = MutableRequest.GET("https://http2-push.appspot.com");
    var publisher = client.exchange(
        request,
        BodyHandlers.ofFile(Path.of("page.html")),
        pushPromise -> BodyHandlers.ofFile(Path.of(pushPromise.uri().getPath()).getFileName()));

    JdkFlowAdapter.flowPublisherToFlux(publisher)
        .doOnNext(response -> System.out.printf("%s: %s%n", response, response.body()))
        .blockLast();
    ```

## MutableRequest

`MutableRequest` is an `HttpRequest` that implements `HttpRequest.Builder` for settings request's
properties. This drops immutability in favor of some convenience when the request is sent immediately.

```java
var response = client.send(MutableReqeust.GET(uri), BodyHandlers.ofString());
```

Additionally, `MutableRequest` accepts relative URIs (standard `HttpRequest.Builder` doesn't). This
is a complementing feature to `Methanol`'s base URIs, against which relative ones are resolved.

!!! tip
    You can use `MutableRequest::toImmutableRequest` to get an immutable `HttpRequest` snapshot.

[interceptors]: interceptors.md
[caching]: caching.md
[methanol-brotli]: https://github.com/mizosoft/methanol/tree/master/methanol-brotli

repository: mizosoft/methanol

gha_language: Java

gha_license_id: MIT

repo_name: mizosoft/methanol


text:
# SyncroSim Package Server

## Description
This repository contains metadata for registered syncrosim packages. All packages in this server are intended to be used with the SyncroSim User Interface, and can be installed in the latest version of SyncroSim. For package installation instructions, see the instructions on the SyncroSim documentation website.

## Packages
A complete list of packages on this server can be found here.

## License
See LICENSE.

repository: syncrosim/packages

repo_name: syncrosim/packages


text:
# ScienceMC
A cancelled in-development mod for Minecraft 1.7.10 focused on bringing science to the popular building game.

You can check the progress that was made here: https://docs.google.com/spreadsheets/d/1Xgi_PePCH-5Qs_jlfc1wWTboH-TY3xHz4iCPlNO_E_o/edit?usp=sharing


text:
---
title: Workflow - RDO Trunk repos
---

# Workflow: RDO Trunk repos

TODO

* Explain special -uc case

----

[← DLRN](/what/dlrn) |
[→ Promotion pipeline](/what/promotion-pipeline) |
[↑ TOC](/what)

repository: dsneddon/website

repo_name: dsneddon/website


text:
# Change Log
All notable changes to the "sisa-asm" extension will be documented in this file.

Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.

## [v0.1.0] - 2017-11-25
- Initial release

repository: vicgua/vscode-sisa-asm

repo_name: vicgua/vscode-sisa-asm


text:
A [third-party server](https://www.heroku.com) fetches the file you want to download on your behalf, and encrypts it with some shitty password (1234) so that the encrypted file evades detection from signature-based detectors. Finally, it returns you the encrypted file.

### If you want to self-host

Follow the guide [here](https://devcenter.heroku.com/articles/getting-started-with-python), then replace the `hello/views.py` with the copy provided in this repo.

## License

MIT

repository: ohsyln/download-blocked-files

repo_name: ohsyln/download-blocked-files


text:
# Carrot

Carrot is a .NET lightweight library that provides a couple of facilities over RabbitMQ.

[![install from nuget](https://img.shields.io/nuget/v/Carrot.svg?style=flat-square)](https://www.nuget.org/packages/Carrot)[![downloads](http://img.shields.io/nuget/dt/Carrot.svg?style=flat-square)](https://www.nuget.org/packages/Carrot)

Getting started
====

Just mark your POCO message contracts with `MessageBinding` attribute:

    [MessageBinding("urn:message:foo")]
    public class Foo
    {
        public Int32 Bar { get; set; }
    }

Define your message consumer:

    class FooConsumer : Consumer<Foo>
    {
        public override Task ConsumeAsync(ConsumedMessage<Foo> message)
        {
            return Task.Factory.StartNew(() =>
                                         {
                                             Console.WriteLine("received '{0}'",
                                                               message.Headers.MessageId);
                                         });
        }
    }

Create an instance of `AmqpChannel` providing the RabbitMQ host as input.

	var channel = AmqpChannel.New("amqp://guest:guest@localhost:5672/",
                                  new MessageBindingResolver(typeof(Foo).Assembly));
    var exchange = Exchange.Direct("source_exchange");

    channel.Bind("my_test_queue", exchange)
           .SubscribeByAtLeastOnce(_ => { _.Consumes(new FooConsumer()); });

You're up 'n running! Do not forget to call `AmqpChannel.Dispose()` when your application exits.

Please note that exchanges are not durable by default.
You can rely on proper methods in case:

    var exchange = Exchange.DurableDirect("source_exchange");

You can publish messages as the following:

    channel.PublishAsync(new OutboundMessage<Foo>(new Foo { Bar = 2 }),
                         exchange);

Please note that messages are not durable by default.
If you need durable messaging, make use of `DurableOutboundMessage<T>`:

    channel.PublishAsync(new DurableOutboundMessage<Foo>(new Foo { Bar = 2 }),
                         exchange);

repository: emadb/Carrot

gha_language: C#

repo_name: emadb/Carrot


text:
# Joint

A Joint is a base class that all components considered a node in the hierarchy extend from.
It's functionality can be resumed to:

- Link and unlink other node to form the hierarchy
- Ability to listen and emit events to/from linked nodes or descendants
- Ability to listen and emit events to/from all nodes in the hierarchy (flood/broadcast)

## joint.initialize()

Method called when instantiating a Joint.
Since this class is `abstract`, it's meant to be extended and not used directly.

## joint.on()

`public method` _on(event, fn, [context])_

Adds a listener for an upcast, downcast or broadcast event.
Duplicate listeners for the same event will be discarded.

Namespaces are supported, please read the [events-emitter](https://github.com/IndigoUnited/events-emitter#offevent-fn-context) documentation for more information.

**Parameters**

|                    |          |                                                                             |
| ------------------ | -------- | --------------------------------------------------------------------------- |
| event              | String   | The event name.                                                             |
| fn                 | Function | The handler.                                                                |
| context (optional) | Object   | The context to be used to call the handler, defaults to the joint instance. |

**Returns**

Joint - The instance itself to allow chaining.

```js
var myView = new MyView();
myView.on('delete', function () {
    console.log('user wants to delete', arguments);
});

myView = new MyView();
myView.on('save', function () {
    console.log('user wants to save', arguments);
}, this);
```

## joint.once()

`public method` _once(event, fn, [context])_

Adds a one time listener for an upcast, downcast or broadcast event.
Duplicate listeners for the same event will be discarded.

**Parameters**

|                    |          |                                                                             |
| ------------------ | -------- | --------------------------------------------------------------------------- |
| event              | String   | The event name.                                                             |
| fn                 | Function | The handler.                                                                |
| context (optional) | Object   | The context to be used to call the handler, defaults to the joint instance. |

**Returns**

Joint - The instance itself to allow chaining.

## joint.off()

`public method` _off(event, fn, [context])_

Removes a previously added listener.

**Parameters**

|                    |          |                                        |
| ------------------ | -------- | -------------------------------------- |
| event              | String   | The event name.                        |
| fn                 | Function | The handler.                           |
| context (optional) | Object   | The context passed to the on() method. |

**Returns**

Joint - The instance itself to allow chaining.

```js
var MyController = Controller.extend({
    //..
    index: function () {
        this._view = this._link(new MyView());
        this._view.on('delete', this._delete, this);

        // Later..
        this._view.off('delete');
        // Or..
        this._view.off('delete', this._delete, this);
    },

    _delete: function () {
        //..
    }
});
```

## joint.isDestroyed()

`public method` _destroy()_

Checks if the instance is destroyed.

**Returns**

Boolean - True if it is destroyed, false otherwise

## joint.destroy()

`public method` _destroy()_

Destroys the instance, releasing all of its resources.
Note that all downlinks will also be destroyed.

Internally calls `_onDestroy()` only once, even on consecutive calls to `destroy()`.

## joint._link()

`protected method` *_link(joint)*

Creates a link between this joint and another one.
Once linked, descendants events flow upwards the hierarchy chain.

**Parameters**

|       |       |                                    |
| ----- | ----- | ---------------------------------- |
| joint | Joint | Another joint to link to this one. |

**Returns**

Joint - The joint passed in as the argument.

```js
var MyController = Controller.extend({
    //..
    index: function () {
        this._view = this._link(new MyView());
        //..
    }
});
```

## joint._unlink()

`protected method` *_unlink(joint)_*

Removes a previously created link between this joint and another one.

**Parameters**

|       |       |                                    |
| ----- | ----- | ---------------------------------- |
| joint | Joint | Another joint to link to this one. |

**Returns**

Joint - The instance itself to allow chaining.

## joint._emit()

`protected method` *_emit(event, [args])*

Emits an event.

**Parameters**:

|                 |          |                                             |
| --------------- | -------- | ------------------------------------------- |
| event           | String   | The event name.                             |
| args (optional) | ...mixed | The arguments to pass along with the event. |

**Returns**

Boolean - True if the event was handled by at least one listener, false otherwise.

```js
var MyView = View.extend({
    _events: {
        'click .btn': '_onBtnClick'
    },

    _onBtnClick: function () {
        this._emit('activate', 'foo', 'bar');
    }
});
```

## joint._upcast()

`protected method` *_upcast(event, [args])*

Emits an event upwards the tree until a node listens to it.

**Parameters**:

|                 |          |                                             |
| --------------- | -------- | ------------------------------------------- |
| event           | String   | The event name.                             |
| args (optional) | ...mixed | The arguments to pass along with the event. |

**Returns**

Boolean - True if the event was handled by at least one listener, false otherwise.

```js
var MyView = View.extend({
    _events: {
        'click .btn': '_onBtnClick'
    },

    _onBtnClick: function () {
        this._emit('activate', 'foo', 'bar');
    }
});
```

## joint._downcast()

`protected method` *_downcast(event, [args])*

Fires an event downwards the chain. If a node listens to it, the propagation will stop for that tree.

**Parameters**:

|                 |          |                                             |
| --------------- | -------- | ------------------------------------------- |
| event           | String   | The event name.                             |
| args (optional) | ...mixed | The arguments to pass along with the event. |

**Returns**

Boolean - True if the event was handled by at least one listener, false otherwise.

```js
var MyView = View.extend({
    _events: {
        'click .btn': '_onBtnClick'
    },

    _onBtnClick: function () {
        this._downcast('sizechange');
    }
});
```

## joint._broadcast()

`protected method` *_broadcast(event, [args])*

Fires an event to all the joints.

**Parameters**

|                 |          |                                             |
| --------------- | -------- | ------------------------------------------- |
| event           | String   | The event name.                             |
| args (optional) | ...mixed | The arguments to pass along with the event. |

**Returns**

Boolean - True if the event was handled by at least one listener, false otherwise.

Please read the [_upcast()]() for an usage example.

## joint._onDestroy()

`protected method` *_onDestroy()*

Method called by `destroy()`.
Subclasses should override this method to release additional resources.
The default implementation will also destroy any linked joints.

repository: IndigoUnited/spoonjs-www

gha_language: JavaScript

repo_name: IndigoUnited/spoonjs-www


text:
# Repository for Component Rendering Issue In Edge Browser

## Issue
Stencil component is not getting rendered in Edge (Version 41.16299.1480.0).

## Steps to reproduce
1. ` git clone `
2. ` npm install`
3. ` npm run build --es5`
4. Host the dist folder to anywhere of your choice (I have used live server extension of vscode)
5. change the js hosted path in `test.html` file

P.S. I have tested that component is getting rendered in Chrome/IE

## Note
### This repository is responsible only for regenerating the issue

repository: LalitKushwah/stencil-component-starter

repo_name: LalitKushwah/stencil-component-starter


text:
# svn2git

## Pre-requisites

- Git repository
- Svn repository

## Steps

1. clone the tool kit repositoy centos

```sh
git clone https://github.com/newlight77/centos /apps/centos
cd /apps/centos
```

2. install the svn2git package

```sh
sudo echo prompt password
ansible-playbook ansible/playooks/playbook-svn2git.yml
```

3. Run the migration script

```sh
cd /appli/svn2git

export SVN_URL=your_svn_url
export GIT_URL=your_git_url

docker-compose up

docker-compose down

# in case you want to run that inside the containwer, you override the env variables
    # sh /appli/migrate.sh -s=your_svn_url -g=your_git_url
# you need to change the docker-compose.yml : command: bash

```

The log file resulting from the script execution will be available at [/apps/logs/svn2git-TIMESTAMP.log].

## Reference

[svn2git migration guide](https://github.com/newlight77/centos/tree/master/docs/svn2git-migration-guide.md)
[git svn guide](https://github.com/newlight77/centos/tree/master/docs/git-svn-guide.md)


text:
---
layout: leftnav-page-content
title: About M³ Logo
permalink: /who-we-are/about-logo/
breadcrumb: About M³ Logo
collection_name: who-we-are
---

![M3 Vertical Logos with Tagline in English and Malay](/images/m3-logo-vert.png)

### **About Logo**

The M3 logo is made up of 3 Ms joining together to form a cube. The Ms represent 3 agencies - Muis, MENDAKI and MESRA. The 3-coloured gradients represent the collaboration between the agencies.

Together with the tagline “Maju Bersama M3”, which translates to “Progressing with M3”, the logo represents M3’s commitment to work in synergy and unity to promote a Singapore Malay/Muslim community that progresses together on a meritocracy that is inclusive and collaborative.

branch_name: refs/heads/staging

gha_language: SCSS

gha_license_id: NOASSERTION


text:
# ML Enabler API v1

The API endpoints are documented in detail via [Swagger](/docs). The following are the available endpoints.

## GET /
Health check endpoint

## GET v1/docs
See documentation

## GET v1/model/all
Get all models

## POST v1/model

Subscribe a model with the ML Enabler. The following is an example payload.

```
{
	"name": "looking-glass",
	"source": "developmentseed",
	"dockerhubUrl": "https://hub.docker.com/r/developmentseed/looking-glass"
}

Response is the ID of the model

```

## GET v1/model/<int:model_id>

Fetch information about a model with the `id`

## PUT v1/model/<int:model_id>

Modify model information. The payload looks like:

```
{
	"name": "non-looking-glass",
	"source": "developmentseed",
	"dockerhubUrl": "https://hub.docker.com/r/developmentseed/looking-glass"
}
```

## DELETE v1/model/<int:model_id>

Delete the model

## POST v1/model/<int:model_id>/prediction

Create predictions of a model. The payload looks like:

```
{
	"modelId": 1,
	"version": "2.0.0",
	"bbox": [10.013795,53.5225,10.048885,53.540843],
	"tileZoom": 18
}
```

## GET v1/model/<int:model_id>/prediction/all

Fetch all predictions of the given model. The response is an array of prediction objects.

## GET v1/model/<int:model_id>/prediction

Fetch predictions of a model within the supplied bbox. For example, `model/1/prediction?bbox=5.53,47.23,15.38,54.96`, will fetch all prediction within that bbox. The response is an array of prediction objects.

## POST v1/model/prediction/<int:prediction_id>/tiles

Submit a JSON of tiles ideally from ml-enabler-cli. The payload looks like:

```
{
  "predictionId": prediction_id,
  "predictions": [
    {
    "quadkey": "120201312023333233",
    "predictions": {"ml_prediction": 65536.0},
    "centroid": "SRID=4326;POINT (10.01266479492188 53.54030739150021)",
    "prediction_id": prediction_id
    }
  ]
}

```

## GET v1/model/<int:id>/tiles

Fetch prediction tiles for the model within the give bbox. The aggregation is dependent on the zoom level. For example: `/model/1/tiles?bbox=10.013795,53.5225,10.048885,53.540843&zoom=14`, will fetch the prediction tiles in the bbox and return aggregated values at z14. This uses the latest prediction of the model.

The response looks like:

```
{
    "8": [
        {
            "quadkey": "12020131221002",
            "avg": 61365.1914893617
        },
        {
            "quadkey": "12020131221001",
            "avg": 63304.1379310345
        },
        {
            "quadkey": "12020131221000",
            "avg": 58488.0083333333
        },
        {
            "quadkey": "12020131220111",
            "avg": 54979.025
        },
        {
            "quadkey": "12020131202333",
            "avg": 65244.8
        },
        {
            "quadkey": "12020131203223",
            "avg": 65536
        },
        {
            "quadkey": "12020131221003",
            "avg": 47146.6857142857
        },
        {
            "quadkey": "12020131220113",
            "avg": 64469.4666666667
        },
        {
            "quadkey": "12020131203222",
            "avg": 64271.5625
        }
    ]
}
```

## POST v1/model/<int:id>/tiles/geojson

For a GeoJSON feature collection of polygons, get predictions for each polygon from the model. This uses the latest prediction of the model.

Example payload is:

```
{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {},
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          [
            [
              11.953125,
              51.18622962638683
            ],
            [
              12.689208984375,
              51.18622962638683
            ],
            [
              12.689208984375,
              51.49506473014368
            ],
            [
              11.953125,
              51.49506473014368
            ],
            [
              11.953125,
              51.18622962638683
            ]
          ]
        ]
      }
    },
    {
      "type": "Feature",
      "properties": {},
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          [
            [
              11.53564453125,
              51.59754765771458
            ],
            [
              12.5244140625,
              51.59754765771458
            ],
            [
              12.5244140625,
              51.890053935216926
            ],
            [
              11.53564453125,
              51.890053935216926
            ],
            [
              11.53564453125,
              51.59754765771458
            ]
          ]
        ]
      }
    }
  ]
}
```

repository: japhliet/ml-enabler

repo_name: japhliet/ml-enabler


text:
This is a helper for [Factorio](http://www.factorio.com/) mod makers.
It is a Makefile (tested only with GNU make) that automates the creation of mod
packages from source, including performing some simple keyword expansion (of
tokens like `{{VERSION}}`) in the `info.json` and `*.lua` files.

## Setup ##

To start using this makefile for your package, you'll need to create a few very
simple files:

- The file `PKG_NAME` should contain the name of your mod package. Create it
with something like `echo My-Awesome-Mod > PKG_NAME`.

- The file `VERSION` should contain your current package version. Create it
with something like `echo 1.0.0 > VERSION`.
    - Note: this file is optional. You can also supply the version at run-time,
    either by setting the environment variable VERSION, or by passing it as a
    `make` argument as in `make VERSION=1.0.2`.
    - Alternately, you can create the file `SHORT_VERSION`, which should
    contain a two-part version number (e.g., `0.6`) -- the third part will be
    filled in by appending the number of commits since the last tag matching
    the `v[0-9]*.[0-9]*` wildcard.

- The file `PKG_COPY` should contain a list of any files or folders that should
be directly copied to the output package, i.e., without any variable expansion.
Note that lua files are automatically included regardless of where they are in
the directory tree. Create it with something like `echo locale > PKG_COPY`.
    - Note: the file may contain the names separated by spaces or newlines --
    make doesn't care.
    - Further note: this file is also optional -- if left out, `info.json`,
    `*.md`, and `*.lua` files will be automatically included.

## Usage ##

Once your setup is completed, it should be as simple as typing `make` -- the
output package will be left in the `pkg` directory, which will be created if
necessary.

Should you wish it, you may invoke the specific target `make package`, and
there is also a `make clean` that will clean up the intermediate files, should
you wish to do a completely fresh repackaging.

## Keyword replacements ##

It is possible to insert some tags into your `info.json` or `*.lua` that will
get automatically replaced with the right values from your current
configuration.

At present, there are two possible tags (and they are case-sensitive):

- `{{MOD_NAME}}` (including the braces) will get replaced with the package
name, as set in the `PKG_NAME` file. So if your `info.json` says
`"name":"{{MOD_NAME}}"`, it will be replaced by `"name":"My-Awesome-Mod"`.

- `{{VERSION}}` (including the braces) will get replaced with the version,
given as explained above. Again, this is most useful for your `info.json`
-- `"version":"{{VERSION}}"` will become `"version":"1.0.2"`.

- `{{__FILE__}}` (including the braces and underscores) will get replaced by
the path of the file being processed, relative to the `make` working directory.
In most cases, this should be the plain filename, or something like
`subdir/file.lua`. This is occasionally useful (for, e.g., logging warnings).

## License ##

The source of **factorio-mod-makefile** is Copyright 2015 Octav "narc"
Sandulescu. It is licensed under the [MIT license][mit], available in this
package in the file [LICENSE.md](LICENSE.md).

[mit]: http://opensource.org/licenses/mit-license.html

## Statistics ##

12 'Stop' errors were encountered during the development of this tool. All of
them were terminated with extreme prejudice.

repository: mkaito/factorio-mod-makefile

repo_name: mkaito/factorio-mod-makefile


text:
# Changelog
All notable changes to the "swarmlib" pypi package will be documented in this file.
This project follows [semantic versioning](https://semver.org/).

## 2020-01-19 - v0.4.1
* **Changed** pypi tags to enhance the package's discoverability.

## 2020-01-19 - v0.4.0
* **Added** a feature that a feature that enables the cuckoo search for one of the provided 2D functions. After each step the intermediate solution is plotted.

## 2020-01-09 - v0.3.2
* **Fixed** a bug in the firefly algorithm that caused the application to crash when the ackley function was selected.

## 2019-10-30 - v0.3.1
* **Fixed** a bug in the ACO algorithm that chose the next node by its maximal attractiveness. Now the next node is chosen randomly weighted by its attractiveness

## 2018-12-18 - v0.3.0
* **Added** command line option `--continuous` for the firefly algorithm to indicate, whether the algorithm should run continuously or not
* **Added** logging for the current best and overall best intensity found of the firefly algorithm

## 2018-12-14 - v0.2.0
* **Added** a feature that enables the firefly algorithm for one of the provided 2D functions. After each step the intermediate solution is plotted.

## 2018-11-29 - v0.1.0
* **Added** a feature that performs [2-opt](https://en.wikipedia.org/wiki/2-opt) search once on each partial solution after each iteration. It can be disabled via the argument `--two-opt false`.
* **Fixed** an import bug that caused the application to crash instantly

## 2018-11-23 - v0.0.1
* **Initial Release**
* **Added** a feature that enables solving the Traveling Salesman Problem using the Ant Colony Optimization approach and plots the result afterwards


text:
# TMW-TotalMail-RunScript
Powershell and C# coding to have TMW TotalMail software launch in order with a pause between each program.

Please note that your version of TotalMail on your server may have additional programs that need to run than what the script provides.
These files are just to be used for guidance in creating your own start up script for the TotalMail packages if you are unfamiliar with scripting or programming.

### CONTACT INFORMATION
    Paul Hill
<EMAIL_ADDRESS>
### Copyright 2017

repository: paulghill/TMW-TotalMail-RunScript

repo_name: paulghill/TMW-TotalMail-RunScript


text:
# Run Jenkins pipeline on s390x VM

Nightly builds will be running on s390x VM to build the artifacts and run `acceptance` profile of system test on master branch at 12:00 am EST each day.

The below link can be used to access the Jenkins builds on s390x VMs:
https://<IP_ADDRESS>/job/strimzi-kafka-operator/job/Strimzi_Kafka_Operator_ST/

_**Note: This link may change in the future.**_

repository: strimzi/strimzi-kafka-operator

branch_name: refs/heads/main

repo_name: strimzi/strimzi-kafka-operator


text:
# YouTube-Bot-in-Python-Selenium
How to Create a YouTube Bot that Increases Views using Python Programming Language.

The app is for educational purpose ONLY!

Using Python Programming Language, one ca create a YouTube bot
uisng few lines of code. Making use of for loop, if else statement
to learn how to code.

You can also watch the YouTube Tutorial ideo here.[https://bit.ly/3ii5NA3]

[![YouTube Tutorial Video](https://img.youtube.com/vi/xmts0wsSShU/0.jpg)](https://bit.ly/3ii5NA3)

You can also read more about it here.[https://bit.ly/39T4frt]

[![Read on How to Increase YouTube Views Using Python Script Programming Language – A YouTube View Bot](https://img.youtube.com/vi/xmts0wsSShU/0.jpg)](https://bit.ly/39T4frt)

repository: fstud/YouTube-Bot-in-Python-Selenium

repo_name: fstud/YouTube-Bot-in-Python-Selenium


text:
# Libc

<!-- TODO : Update WIP -->

__This section is not yet online because it is in WIP__

The libc doesn't contain all functions, here is the list of implemented functions.

## Notes

In addition, there is some definitions like NULL or int types.

## string.h

- memcpy
- memset
- strcat
- strdup
- strcmp
- strcpy
- strlen
- strncpy

## stdio.h

- putchar
- printf (partially, see implemented flags in stdio.h)

## ctype.h

- isalnum
- isalpha
- isblank
- iscntrl
- isdigit
- isgraph
- islower
- isprint
- ispunct
- isspace
- isupper
- isxdigit
- tolower
- toupper


text:
## GreenHorn.NameParser
Parses name strings using Western-English naming conventions for human names and identifies organizational names.

## Motivation
Work-related experieneces has brought to my attention many legacy systems utilze code intended to accomplish the same task but may be written in different ways even if the code base is written in the same programming language.
As such, I was in need of a name parsing library written by an approved developer that can be used within my organization with the ability to parse human names into their respective elments  and identify organizational names based on specific criteria (`Prefix`, `First`, `Middle`, `Last`, `Suffix`, `IsOrganization`).

## Build status

## Code style
[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://github.com/feross/standard)

## Screenshots

## Tech/framework used

<b>Built with</b>
-C#
-.Net Framework 4.6.1

## Features
This library is intended to be extendable by providing access to a NameConfiguration class. Multiple configurations components have the ability to add, remove, and/or replace portions or entire configuration elements.

```csharp
public class Configuration
    {
        ...
        public List<string> Prefix { get; set; };
        public List<string> Suffix { get; set; };
        public List<string> CompoundName { get; set; };
        public List<string> BusinessIndicator { get; set; };
    }
```
## Code Example
usage:

`C#`

```csharp
NameParser parser = new NameParser();
var parsedName = parser.Parse("Foo Bar");

var parsedName = new NameParser().Parse("Mr. Foo P. Bar");
```
`VB.Net`

```vb
Dim parser as NameParser = new NameParser()
Dim parsedName = parser.Parse("Foo Bar")

Dim parsedName as Name = new NameParser().Parse("Mr. Foo P. Bar");
```

[//]: # (## Installation)
[//]: # (Provide step by step series of examples and explanations about how to get a development env running.)

[//]: # (## API Reference)

[//]: # (Depending on the size of the project, if it is small and simple enough the reference docs can be added to the README. For medium size to larger projects it is important to at least provide a link to where the API reference docs live.)

## Tests
Tests have been created as part of the GreenHorn.NameParser project using the Microsoft Testing Framework.

Example:
```csharp
public const string E = "";

        [DataTestMethod]
        [DataRow("Foo", E, "Foo", E, E, E, false)]
        [DataRow("Foo Bar", E, "Foo", E, "Bar", E, false)]
        [DataRow("Foo Bar Jr", E, "Foo", E, "Bar", "Jr", false)]
        [DataRow("Foo Bar Jr.", E, "Foo", E, "Bar", "Jr.", false)]
        [DataRow("Foo P. Bar", E, "Foo", "P.", "Bar", E, false)]
        [DataRow("Mr Foo Bar", "Mr", "Foo", E, "Bar", E, false)]
        [DataRow("Mr. Foo Bar", "Mr.", "Foo", E, "Bar", E, false)]
        [DataRow("Mr Foo P. Bar III Phd.", "Mr", "Foo", "P.", "Bar", "III Phd.", false)]
        [DataRow("Mr. Foo P. Bar III Phd.", "Mr.", "Foo", "P.", "Bar", "III Phd.", false)]
        [DataRow("Mr Foo P. Bar III Phd", "Mr", "Foo", "P.", "Bar", "III Phd", false)]
        [DataRow("Mr. Foo P. Bar III Phd", "Mr.", "Foo", "P.", "Bar", "III Phd", false)]
        [DataRow("Foo della Bar", E, "Foo", E, "della Bar", E, false)]
        [DataRow("Foo della Bar", E, "Foo", E, "della Bar", E, false)]
        [DataRow("Mr Foo della Bar", "Mr", "Foo", E, "della Bar", E, false)]
        [DataRow("Mr. Foo della Bar", "Mr.", "Foo", E, "della Bar", E, false)]
        [DataRow("fr Foo Bar", "fr", "Foo", E, "Bar", E, false)]
        [DataRow("Fr Foo Bar", "Fr", "Foo", E, "Bar", E, false)]
        [DataRow("fr. Foo Bar", "fr.", "Foo", E, "Bar", E, false)]
        [DataRow("Fr. Foo Bar", "Fr.", "Foo", E, "Bar", E, false)]
        public void NameParser_Parse_correctly_returns_parses_human_name(
            string fullName,
            string prefix,
            string firstName,
            string middleName,
            string lastName,
            string suffix,
            bool isBusinessName
            )
        {
            Name expectedResult = new Name() {
                Prefix = prefix,
                First = firstName,
                Middle = middleName,
                Last = lastName,
                Suffix = suffix,
                IsOrganization = isBusinessName
            };
            var parser = new NameParser();
            var results = parser.Parse(fullName);

            Assert.AreEqual(
                expected: expectedResult,
                actual: results);
        }
```

## How to use?

1. Start by cloning this project into Visual Studio.
2. Build the project.
3. Copy the resulting GreenHorn.NameParser into your client prject.
4. Add a reference to the GreenHorn.NameParser.dll.
5. Implment name parsing logic based on above `Code Example`.

## Contribute

Contributions are always welcome!

###Contribution Guidelines
Please ensure your pull request adheres to the following guidelines:

- Alphabetize your entry.
- Search previous suggestions before making a new one, as yours may be a duplicate.
- Suggested READMEs should be beautiful or stand out in some way.
- Make an individual pull request for each suggestion.
- New categories, or improvements to the existing categorization are welcome.
- Keep descriptions short and simple, but descriptive.
- Start the description with a capital and end with a full stop/period.
- Check your spelling and grammar.
- Make sure your text editor is set to remove trailing whitespace.

Thank you for your suggestions!

## Credits
Yes, there are several libraries availble that accomplish the same task as this library and this library has been deviation of the following:

**Similar logic, more languages**

* [Name Parser in Java](https://github.com/gkhays/NameParser)
* [Name Parser in JavaScript](https://github.com/joshfraser/JavaScript-Name-Parser)
* [Name Parser in CSharp](https://github.com/ianlee74/CSharp-Name-Parser)

#### Anything else that seems useful

## License
[![GitHub license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/GreenHornSoftware/GreenHorn.NameParser/blob/master/LICENSE)


text:
# # CommonResponseObjDebug

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**sMemoryUsage** | **string** | The peak memory allocated during the API request execution. Formatted as a human readable string |
**sRunTime** | **string** | The total server execution time of the API request execution. Formatted as a human readable string |
**iSQLSelects** | **int** | The number of SQL SELECT queries that were sent to the database server during the API request execution |
**iSQLQueries** | **int** | The number of SQL INSERT/UPDATE/DELETE queries that were sent to the database server during the API request execution |
**aObjSQLQuery** | [**\eZmaxAPI\Model\CommonResponseObjSQLQuery[]**](CommonResponseObjSQLQuery.md) | An array of the SQL Queries that were executed during the API request execution |

[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md)

repository: eZmaxinc/eZmax-SDK-php

repo_name: eZmaxinc/eZmax-SDK-php


text:
Sockets: Which One To Pick
==============================

CCI supports a variety of services, mostly centered around Twitch. (Not much choice when it comes to YouTube, I'm afraid.) This page is to highlight the subtle differences that may not be immediately obvious when selecting a service.

| Support             | Streamlabs | StreamElements |   Twitch PubSub   | Twitch Chat |
| ------------------- |:----------:|:--------------:|:-----------------:|:-----------:|
| Bits/Cheers         |     ✓      |       ✓        |         ✓         |             |
| Subscriptions       |     ✓      |       ✓        |         ✓         |             |
| Sub Gift Bombs      |     ✓      |  To a degree   |         ✓         |             |
| Follows             |     ✓      |       ✓        |         ✓         |             |
| Incoming Raids      |     ✓      |       ✓        |                   |      ✓      |
| Outgoing Raids      |            |                |         ✓         |             |
| Hosts               |     ✓      |       ✓        |                   |      ✓      |
| Tips                |     ✓      |       ✓        |                   |             |
| Twitch Chat         |            |                | Moderation events |      ✓      |
| Polls               |            |                |         ✓         |             |
| Predictions         |            |                |         ✓         |             |
| Hype Trains         |            |                |         ✓         |             |
| Channel Points      |            |                |         ✓         | To a degree |
| Leaderboard Updates |            |                |         ✓         |             |
| Replaying Events    |     ✓      |       ✓        |                   |             |

Above is a summary of what each service supports. For the full Twitch experience, combine Twitch PubSub and Chat. What Streamlabs and StreamElements does (speculated), is that it connects to both your PubSub and Chat, and adds on their own tips/donations page, and serve their package.

What you can do, is either Streamlabs or StreamElements, and Twitch PubSub and Twitch Chat to fill in the gaps. I expect most of you to already be using either Streamlabs or StreamElements, so the defaults for Twitch PubSub do not overlap with them.

## Streamlabs and StreamElements, what's the difference?

They're essentially competing services, and for the most part, provide the same thing. With CCI however, the way they implement events differs slightly. For example, StreamElements does not have a `Gift to the Community` event and instead inserts that info during a subscription event, while Streamlabs has a separate event just for that purpose. Their event type IDs are also different, `bits` in Streamlabs vs `cheer` on StreamElements, `follow` on Streamlabs vs `follower` on StreamElements.

Point is: **They do things differently**. What that means is Event Configs for one will not work on the other. You'll have to try and convert them if want to use a Streamlabs config on a StreamElements setup and vice versa. Their event variables will not match up and you may encounter some errors as well. There is no proper list or guide on converting the two, however, so you'll have to go off trial and error.

gha_language: HTML


text:
# _Mr. Roboger's Neighborhood_

#### By _**Matt Stroud**_
##### _Last Updated April 3, 2020_

## Description

_An independent project from Epicodus._
_This application takes a number as input, and displays a list of numbers from 0 to the number_
_With the following exceptions, from least to most important:_
* _Numbers that contain a 1: all digits are replaced (all digits) with "Beep!"_
* _Numbers that contain a 2: all digits are replaced (all digits) with "Boop!"_
* _Numbers that contain a 3: all digits are replaced (all digits) with "Won't you be my neighbor?"_

## Specs

| Behavior                                                                                | Input   | Output                                                |
|:--------------------------------------------------------------------------------------------------|:-------:|------------------------------------------------------:|
| The program returns an error if the input is not a number.                                        | "Hello" | Error                                                 |
| The program returns a range of numbers from 0 to the users inputted number.                       | 4       | 0,1,2,3,4                                             |
| The program returns "Won't you be my neighbor?" instead of the current number if it contains a 3. | 3       | 0, 1, 2, "Won't you be my neighbor?"                  |
| The program returns "Boop!" instead of the current number if it contains a 2.                     | 5       | 0, 1, "Boop!", "Won't you be my Neighbor?", 4, 5      |
| The program returns "Beep!" instead of the current number if it contains a 1.                     | 2       | 0, "Beep!", "Boop!"                                   |
| The program clears all displayed results whenever the user enters another number.                 | 1 -> 2  | 0, "Beep!" -> 0, "Beep!", "Boop!"                     |
| The program inserts the user's name to the result if the number is divisible by 3.                | 3       | 0, "Beep!", "Boop!", "Won't you be my neighbor, Dana? |
| The program reverses the output if user selects the appropriate option.                           | 2       | "Boop!", 1, 0                                         |

## Known Bugs

* inserting user's name into the output not currently implemented.

## Setup/Installation Requirements

* Clone this repository.
* Navigate to index.html file.
* Right click and open in the browser of your choice.

## View Online

* View at https://mlstroud.github.io/mr-rogers-neighborhood

### License

This software is licensed under the MIT license.

Copyright (c) 2020 **Matt Stroud**

repository: mlstroud/mr-rogers-neighborhood

repo_name: mlstroud/mr-rogers-neighborhood


text:
---
layout: post
title: "Reasoning about disclosure in data integration in the presence of source constraints"
date: 2019-06-03 08:18:12
categories: arXiv_AI
tags: arXiv_AI Knowledge
author: Michael Benedikt, Pierre Bourhis (CRIStAL, CNRS, SPIRALS), Louis Jachiet (CRIStAL, CNRS, SPIRALS), Michaël Thomazo (DI-ENS, ENS Paris, CNRS, PSL, VALDA )
mathjax: true
---

* content
{:toc}

##### Abstract
Data integration systems allow users to access data sitting in multiple sources by means of queries over a global schema, related to the sources via mappings. Data sources often contain sensitive information, and thus an analysis is needed to verify that a schema satisfies a privacy policy, given as a set of queries whose answers should not be accessible to users. Such an analysis should take into account not only knowledge that an attacker may have about the mappings, but also what they may know about the semantics of the sources. In this paper, we show that source constraints can have a dramatic impact on disclosure analysis. We study the problem of determining whether a given data integration system discloses a source query to an attacker in the presence of constraints, providing both lower and upper bounds on source-aware disclosure analysis.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1906.00624](http://arxiv.org/abs/1906.00624)

##### PDF
[http://arxiv.org/pdf/1906.00624](http://arxiv.org/pdf/1906.00624)


text:
Digital Bitbox Firmware
============

[![Build Status](https://travis-ci.org/digitalbitbox/mcu.svg?branch=master)](https://travis-ci.org/digitalbitbox/mcu)
[![Coverage Status](https://coveralls.io/repos/github/digitalbitbox/mcu/badge.svg?branch=master)](https://coveralls.io/github/digitalbitbox/mcu?branch=master)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/7041/badge.svg)](https://scan.coverity.com/projects/mcu)
[![license](https://img.shields.io/github/license/mashape/apistatus.svg)]()

**MCU code for the [Digital Bitbox](https://digitalbitbox.com) hardware wallet.**

All communication to the hardware wallet enters and exits a single gateway `char *commander(const char *command)` that receives an encrypted command and returns an encrypted reply. The communication protocol is described in the [API](https://digitalbitbox.com/api.html).

The code can be compiled and tested locally without the need for a device. See the `tests_cmdline.c` code for a simple example and the `tests_api.c` code to test the full API. The `tests_api.c` code will also test a live device if one is plugged into a USB slot. This requires installation of the [hidapi library](http://www.signal11.us/oss/hidapi/) for USB communication, a micro SD card in the device, and a number of touch button presses to permit `erase` and `sign` commands. WARNING: data on the device and micro SD card will be **lost** when running `tests_api.c`.

ECDSA signatures are performed with either the [bitcoin core secp256k1 library](https://github.com/bitcoin/secp256k1) or using a simplified version of the smaller [micro ECC library](https://github.com/kmackay/micro-ecc), depending on a setting in the `CMakeLists.txt` file. Each library is resistant to known side channel attacks.

**Standardized functions:**

	Cryptographic: secp256k1, RFC6979, AES-256-CBC, SHA2, HMAC, PBKDF2, RIPEMD160
	Encoding: Base-64, Base-58-check, JSON
	Bitcoin: BIP32, BIP39, BIP44

## Build Instructions

#### Building test code:

Dependencies:

- [HIDAPI](https://github.com/signal11/hidapi) (For live testing)
- Doxygen (Optional, to generate source code documentation)
- Graphviz (Optional, to generate graphs for the Doxygen documentation)

Build:

    git clone https://github.com/digitalbitbox/mcu && cd mcu
    mkdir build && cd build
    cmake .. -DBUILD_TYPE=test # `-DBUILD_TYPE=firmware` and `-DBUILD_TYPE=bootloader` work if a GNU ARM toolchain is installed
    make
    make test

#### Deterministic build of firmware:

### Build environment with Docker and Debian Stretch:

Requires:

- [Docker CE](https://download.docker.com/)

To build the base image:

    docker build --tag shift/mcu-base -f Dockerfile.dev .

To build and run the full set of tests with both gcc and clang:

    docker build --tag shift/mcu-base-ci -f Dockerfile.tests .

To use the base container:

    docker run -it shift/mcu-base

To use the contious integration container:

    docker run -it shift/mcu-base-ci

This build process Debian Stable (Stretch).

## Contributing
Please do not use an editor that automatically reformats.

Please do use the coding style set by AStyle version 3.0 (http://astyle.sourceforge.net/; also available from homebrew) with the following parameters:

    astyle --style=kr --indent-switches --indent-labels --pad-oper --pad-header --align-pointer=name --add-braces --convert-tabs --max-code-length=90 --break-after-logical --suffix=none *.c *.h --recursive --exclude=src/yajl --exclude=src/secp256k1 --exclude=src/drivers --exclude=tests/hidapi | grep Formatted

Pull requests will automatically fail if the coding style is not met. For convenience, enable a Git hook to trigger the `astyle` styling whenever a `git commit` operation is performed. This is done by typing in the repository directory:

    cd .git/hooks
    ln -s ../../contrib/git/pre-commit

All commits must be signed with PGP. To set Git to auto-sign your commits:

    git config --global user.signingkey YourGPGKeyID
    git config --global commit.gpgsign true

The PGP public keys of the contributors can be found in contrib/contributors_gpg_keys. Please add your PGP key with your first pull request.

repository: Tomasvrba/mcu

repo_name: Tomasvrba/mcu


text:
---
layout: project-post
title: AgriBot
date: 2015-05-02
tags: [competition,robotics,cv,ee,embedded,team]
status: publish
type: post
published: true
comments: true
author: andrey_kurenkov
projcategory: team_projects
projname: agribot
excerpt: A robotic rover for autonomously mapping and spraying plants
image:
  feature: poster.png
  teaser: robot.png
what: A robotic rover for autonomously mapping and spraying fields of plants
who: Me, Trony O'Neil, Pavel Komarov, Richard Nagendran, Robert Choi
why: Irrigation is massively wasteful, and a more precise system would be useful. The SLAM part is honestly more exciting.
where: Georgia Tech, senior design for the EE degree
when: August 2014-April 2015
links:
  - name: Overview
    isfile: true
    file: writeup.pdf
  - name: Technical Docs
    isfile: true
    file: technicaldocs.pdf
  - name: Presentation
    isfile: true
    file: presentation.pdf
images:
  loop: true
  basename: agribot
  ext: png
  num: 16
videos:
  - name: LIDAR Test
    src: https://www.youtube.com/embed/RMAdnCO-09w
    caption: Fun times working on robots
    alt: LIDAR Test
---
Wow, what a senior design project. Getting a roughly 30k robot rover and being tasked with putting roughy 5k of electronics and sensors on top of it. And the software! To make a self driving, autonomous mapping robot that precisely sprayed plants and gathered data with the possibility of remote control and monitoring.

What a project - a serious enough one to the point of not being able to finish, apparently. A lot was working on that Jetson TK1, intense ROS-based SLAM code with Kinect 2 and SLAM input, navigation of the robot, and so much more (the technical docs and presentation have all the juicy details) - but as happens so often we did not pull it all together in time. Still, we were close, and for a project of such ambition that means something.

branch_name: refs/heads/source

gha_language: Jupyter Notebook


text:
# Recipebook (front-end)

A project born out the love of cooking and eating great food! My wife and I needed a place to store our favorite recipes and have them available anywhere in the world and this is the front-end portion of  the project.

## Tech
Build with React, Redux, TailWindCSS and Axios

## Features
* Mobile friendly
* Create, Read, Update and Delete recipes, steps and ingredients.
* Search recipes by name
* Search recipes by ingredient
* Group ingredients by type
* Add image URLs of your favorite creations

## Backend
Built with Java Spring Framework. Can be found  [here](https://github.com/kai-blt/recipebook-backend)

repository: kai-blt/recipebook-frontend-tailwind

repo_name: kai-blt/recipebook-frontend-tailwind


text:
Compilation
===========

Make sure you have the following prerequisites installed:
- [protobuf (2.4.1)](http://code.google.com/p/protobuf)
    - The `protoc` command should be in your path.
    - You can run `PROTOC=/path/to/protoc make` if that's not the case.
- [snappy (1.0.5)](http://code.google.com/p/snappy)

You can then compile the project by simply running `make`. (But read the
compile-time settings section beforehand.) If anything is in a non-standard
location, you can add compiler options using a hack like

    CXX="g++ -I/more/include/paths -L/more/library/paths" make

Compile-time settings
---------------------
There are some settings you can choose at compile-time in order to control
what is output. Yes, this would be friendlier if those were runtime arguments,
but life's not friendly. This allows for minimal changes to the demoinfo2 code
which Valve "promised" to update at some point. You do know what
[Valve promises](https://developer.valvesoftware.com/wiki/Valve_Time) are, do you?

Enable these settings by adding CXX flags:

    CXX="g++ -DOUTPUT_AUTODEMSON_USER -DOUTPUT_AUTODEMSON_NET" make

### OUTPUT\_ORIGINAL
Output whatever the original demoinfo2 code would have output.

### OUTPUT\_AUTODEMSON\_[USER,NET]
Output demson types generated automatically through reflection.

This is useful in that you get _everything_, i.e. all message and even "hidden"
fields, which are present in the data but not in the protobuf files.
(Those were mostly added after the release of demoinfo2.)

This is useless in that you get tons of useless messages and many messages have
a less-than-optimal design. Disabling this gives you a hand-curated list of
demsontypes which also expose a friendly interface.

`USER` and `NET` are just two different categories of messages. The user
messages seem to be more related to the dota game while the net messages seem
to be related more to steam engine's generic internals, although they contain
some very dota-related stuff too.

#### OUTPUT\_RAWDATA\_IN\_DEMSON
Some `NET` messages contain raw data buffers. These are output as json strings
where non-printable characters are escaped as hex as in `\xFF`. This encoding
of raw data into strings causes problems with some loading libraries (namely,
python's `json` module). This options will just skip these messages.

TODO: We need to investigate these messages and find out what's hidden in the
raw data, as it's probably interesting.

### OUTPUT\_`some message type`
`some message type` is a string consisting of only the "useful" part of the
message name. For example, for a `CDOTAUserMsg_LocationPing`, the "useful"
part is `LocationPing` and thus the define is called `OUTPUT_LocationPing`.

Messages for which this is defined are _additionally_ output by a hand-crafted
json outputting routine, thus potentially being easier to handle.

Currently, the following ones exist:

    * `OUTPUT_LocationPing`
    * `OUTPUT_GameEvent`
    * `OUTPUT_ChatEvent`

Usage
=====

    ./demoinfo2 replay.dem > replay.rawdemson

You'll probably want to postprocess the output using a higher-level tool.
A tool for converting the "names" present in the combatlog gameevents into
actual strings (from the stringtables) is included in this repo since it is
tightly connected:

    python ids_to_names.py < replay.rawdemson > replay.demson

Note that only the combatlog gameevents are output by this script.

Output format
=============
Currently, each line of the file contains a json object. This object is always
a dict which contains at least the key `demsontype`. This key determines the
shape of the dict - it is its class if you like to think static typing.

demsontype
----------
Each json object has a key `demsontype`, which fully specifies what kind of
data is contained in this particular line. This can also be used for debug purposes.
(see `debug_ignored_stringtable`)

fileinfo
--------
`"demsontype": "fileinfo"`

Contains the game's length in seconds (`playback_time`), ticks (`playback_ticks`) and frames (`playback_frames`).

gameinfo
--------
`"demsontype": "gameinfo"`

Contains very useful info about the game like the `match_id`.
* `game_mode`: TODO
* `game_winner`: TODO (wtf is 3? why not only 0/1 or so?)
* `players`: A list of information (dicts) about the players in the game.
    * `hero_name`
    * `player_name`: the nickname, not steam/server id.
    * `is_fake_client`: boolean. Didn't see any `true` yet.

String table
------------
`"demsontype": "stringtable"` or `"demsontype": "stringtable_ignored"`

The string table only gets extended over time, meaning that what is the 3rd
entry at the beginning of the replay will stay the 3rd entry until the end.
This also implies the string table only grows.

Currently only stringtables of type `"demsontype": "stringtable_combatlog"` are completely printed.

Game event
----------
`"demsontype": "gameevent"`

Each game event has a `evname` and a `evid` key whose value describes the type
of the game event. As of now, it seems this information is redundant. The
'evname2' key seems to be empty for all game events we can parse.

The remainder of the game event entries is dependent of the type of the event.
For the `dota_combatlog` event, all "names" are keys of the (full, upcoming)
`combatlog` string table. For other events, like `dota_chase_hero`, the `target`s
seem to be entity ids which we can't get a hold of yet.

### Combatlog game events
This might be one of the most interesting gameevents. It describes some interaction
between entities, like damaging, healing, stunning, ...

TODO: find out what exactly the different `name`s, `health` and `value` mean in each case.

#### type: 0
burst damage being dealt, as opposed to damage over time (more details need to be determined).
Includes spell damage. `value` is the effective damage dealt, i.e. after all resistances have been
computed. `health` seems to be the target's health left after the damage has been dealt.

#### type: 1
burst healing, as opposed to healing over time. Examples of this are lifeleech and magic stick.
No salve, no tango.

#### type: 2
seems to be spell damage/modifiers. Unsure

#### type: 3
same as above. What's the difference?

#### type: 4
Seems to be kills, including creeps and building kills. This seems to be the case because the health
is always 0. TODO: check this by watching the replay alongside the data.

Credit
======
Original software released by Valve, OSX port by Armin (mitsuhiko).

Original copyright from Valve:
<pre>
====== Copyright (c) 2012, Valve Corporation, All rights reserved. ========

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

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

extension: markdown


text:
# Extern guidelines

This document describes the principles used in `hxnodejs` regarding package structure, naming, typing and useful tricks.
It is advised to follow these guidelines when creating externs for third-party node modules.

## Package structure

If a node module contains functions and/or variables, an extern class with static functions is created with capitalized name of that module. For that class, a `@:jsRequire("modulename")` metadata is added, so it's automatically `require`d on use.

For example:

```haxe
@:jsRequire("fs")
extern class Fs {
    static function writeFileSync(filename:String, data:String):Void;
}
```

If a module contains classes, a package is also created for that module and the classes are placed inside that package. For example:

```haxe
package fs;

extern class Stats {
    // ...
}
```

If that class is supposed to be available to user for creating with `new`, the `@:jsRequire("modulename", "ClassName")` metadata is added. For example:

```haxe
package events;

@:jsRequire("events", "EventEmitter")
extern class EventEmitter implements IEventEmitter {
    function new();
    // ...
}
```

Example module layout:
 * root
   * events
     * EventEmitter.hx
   * fs
     * Stats.hx
     * FSWatcher.hx
   * Fs.hx

### Imports

It makes sense to use e.g. `import fs.*` in the `Fs.hx` so that all relevant classes are brought into context of the module static class. Other than that, usual import recommendations apply: import only what's necessary and remove unused imports.

## Naming

All modules, classes, fields and functions arguments should be named after the official API documentation of the native module. Static classes representing node modules are capitalized as they are Haxe types and must follow haxe type naming requirements. Acronyms are NOT uppercased (i.e. `Json`, not `JSON`).

In case Haxe name for a node.js module matches the name of its inner class, that class is imported into module using `import as`, adding `Object` as a postfix. For example:

```haxe
import js.node.child_process.ChildProcess as ChildProcessObject; // class representing node.js inner class

@:jsRequire("child_process") // class representing node.js module
extern class ChildProcess {
    static function spawn(/*...*/):ChildProcessObject;
}
```

## Events

Node.js event emitters take strings as event names and don't check listener signatures in any way. The hxnodejs extern for `EventEmitter` supports that behaviour for convenience of copy-pasting JavaScript code. However it also provides a way to type-check event listeners.

If you provide an instance of `Event<T>` abstract string type where an event name is expected in any `EventEmitter` method, then the listener type will be unified with `T` and thus provide type checking and inference for the listener function.

We provide [@:enum abstract types](http://haxe.org/manual/types-abstract-enum.html) that enumerate possible event names for a given event emitter. They are implicitly castable to `Event<T>` and can be used for type-checking listener functions as described above. For each `EventEmitter` subclass, an `@:enum abstract` type must be created with a `Event` postfix in its name. For example, if we have a `Process` class which is an `EventEmitter`, it should have a pairing `ProcessEvent` type in its module, i.e.:

```haxe
extern class Process extends EventEmitter {
    // ...
}

@:enum abstract ProcessEvent<T:haxe.Constraints.Function>(Event<T>) to Event<T> {
    var Exit : ProcessEvent<Int->Void> = "exit";
}
```

In the example above, the listener type for the 'exit' event is `Int->Void` which means it takes `Int` as its first argument and returns nothing.

Event constant names are `UpperCamelCase` and their values are actual event names.

## Method overloading and optional arguments

TODO (describe the difference of overloading/optional argument concepts and advise where to use which and that, describe `haxe.Rest`)

## Typing

The whole idea of haxe externs is provide a fully type-checked access to external API. Considering that, we must avoid the need for use `Dynamic` type or `cast` and think of a way to properly express type restrictions.

On the other hand, we want developers to be able to copy-paste node.js code into haxe with minimal modification and have it compiling. For that reason we have to weaken some typing restrictions, for example adding implicit cast `from String` for our `@:enum abstract` types.

### Multiple inheritance

TODO (describe how to deal with multiple inheritance using interfaces, as we do with IReadable/IWritable streams, mention `@:remove` metadata for interfaces).

### Chaining methods

TODO (describe how to use type parameters + interface to properly type chaining methods)

### Object structures

When a function takes/returns an object with predefined fields (e.g. options argument in many node.js methods), [anonymous structures](http://haxe.org/manual/types-anonymous-structure.html) are used along with `typedef`s.

Example:
```haxe
typedef FileOptions = {
    var path:String;
    @:optional var encoding:String;
    @:optional var mode:Int;
}

function readFile(options:FileOptions):Void;
```

**TODO describe typedef naming**

### Dynamic objects

If a JavaScript object is intended to be used as a *keyed collection* of values and thus doesn't have a predefined structure (e.g. `process.env`), use `haxe.DynamicAccess<T>`. It's a special abstract type designed just for that. It provides `Map`-like API for iterating over its keys and working with values.

Note that in some cases, an object doesn't have a predefined structure, but neither is a *collection*. In those cases, use simple `Dynamic<Dynamic>`.

### Either types

If a function accepts different types for a single argument, at the most times it is better to use `@:overload` do describe that. However there are cases where it is not sufficient, for example: a collection can contain elements of different (but limited) types or an options object field can be of either type.

To deal with that Haxe provides the `haxe.EitherType<T1,T2>` type that is an abstract over `Dynamic` that can be implicitly casted from and to both `T1` and `T2`.

Example:
```haxe
typedef SomeOptions = {
    var field:haxe.EitherType<String,Array<String>>;
}
```
Here, the `SomeOptions.field` can be assigned to/from either a string or array of strings.

If a type can be of 3 and more types, nested `EitherType` can be used.

### Constant enumeration

If there's a finite set of posible values for a function argument or object field, [@:enum abstract types](http://haxe.org/manual/types-abstract-enum.html) are used to enumerate those values.

Example:

```haxe
@:enum abstract SymlinkType(String) from String to String {
    var File = "file";
    var Dir = "dir";
    var Junction = "junction";
}
```

The `to` and `from` implicit cast must be added so user can use both enumeration constants and original values as documented in API documentation of native library, however `from` cast may be omitted if the type is used only for return values and is not supposed to be created by user.

Constant names are `UpperCamelCase` and their values are actual values expected by native API.

Note that combined with `haxe.EitherType` (described above), `@:enum abstract`s can handle even complicated cases where a value can be of different types, e.g.

```haxe
@:enum abstract ListeningEventAddressType(haxe.EitherType<Int,String>) to haxe.EitherType<Int,String> {
	var TCPv4 = 4;
	var TCPv6 = 6;
	var Unix = -1;
	var UDPv4 = "udp4";
	var UDPv6 = "udp6";
}
```

## API Documenting

We use API documentation style found in Haxe standard library and copy upstream API documentation text to externs (applying some minor editing/reformatting to it).

Example of Haxe standard library style:

```haxe
/**
	Does that and returns this.

	Some more info about using argument `a` and `b`.
**/
static function doStuff(a:Int, b:String):Void;
```

Note that node.js API documentation often describes types of variables which is mostly redundant in Haxe, so these parts can be removed.

## Deprecated API

Use `@:deprecated` metadata for upstream API that is deprecated. That way compiler will emit a warning when using deprecated API.

Example:
```haxe
@:deprecated // default warning message
extern class DeprecatedClass {
}

extern class NotSoDeprecated {
	@:deprecated("use otherMethod instead") // custom warning message
	function deprecatedMethod():Void;

	function otherMethod():Void;
}
```

## Tricks and hints

TODO (dealing with keywords, `untyped __js__`, inline methods and properties on extern classes)

repository: HaxeFoundation/hxnodejs

gha_language: Haxe

repo_name: HaxeFoundation/hxnodejs


text:
# ESP-DSP ESP32-Azure IoT kit 3d graphics demo application

The demo is developed for [ESP32-Azure IoT kit](https://github.com/espressif/esp-bsp/tree/master/esp32_azure_iot_kit) development board and is demonstrating the usage of matrices with `ESP-DSP` `Mat` class, Kalman filter and basic 3D graphics.

The 3D Graphics demo displays a 2D graphics, converted to 3D as a 3D rotating object, on the development board's display. Button press changes the rotation direction of the 3D object. Run the menuconfig using the following command:

    idf.py mencuonfig

In the menuconfig's menu item `Demo user configuration` select which 3D object to display. It's either a 3D cube, or ESP logo, or a user-defined graphics. Getting the user-defined graphics is described in an [example](../../graphics/img_to_3d_matrix/example/)

## Running the demo

To start the demo, run the following command:

    idf.py build flash monitor

The expected output is the following:

    I (570) 3D image demo: Selected 3D image - ESP Logo
    I (570) 3D image demo: Showing ESP text
    I (6730) 3D image demo: Showing 3D image

Note, that the first line `Selected 3D image` from the expected output depends on the user's Kconfing menu selection

repository: espressif/esp-dsp

gha_language: C

repo_name: espressif/esp-dsp


text:
---
layout: post
title: "Vince"
date: 2015-10-26 10:00
comments: true
categories: [personal]
---

I sit at my desk trying to find some words to preface this post.

A year ago today my grandpa died.

<!-- more -->

I said it. My body goes electric as my throat constricts and I will back the
growing pressure of tears welling behind my eyes.

I needed you; need you still.

It's been the hardest year and the one person in the world that I want to share
it with is gone. How do I know if he's proud? How do I know I'm doing right?
No one is there to ask "What do you think, grandpa?".

Too much.

My cheeks are wet and I realize that I've written pure nonsense.

Sorry.

No, I'm not sorry.  The words
for him - the words I said in front of family and strangers when he wasn't
around to hear them.

## Spoken Eulogy November 1st, 2013

Vince was so many things to so many different people: a father, a husband, a grandfather, an army captain, and various official and unofficial titles where he lived and served around his community.  To me, he was more than just a grandfather, he was my friend, my buddy, and my role-model.

Today, I want to share with you some of the things that I’m still learning from my grandfather, my friend, my role-model:

Humility.

 Instead, with his logician’s mind and his trap-door memory for random trivia, he was the type of guy who you could ask anything and he probably would know it; if he didn’t, he didn’t have trouble saying “I don’t know”. I think this is what made “Vince and Gloria” such a great team. He knew when the “glo” in “vinglo” was better at something than he was, and he was smart enough to let her handle it.

Responsibility.

Speaking of the “glo” in “vinglo”. One of the most vivid childhood memories, and life lessons came from grandpa when I was about 7 or 8.  I was "being a kid" during an uno game at one of those famous “vinglo” holiday parties. I don’t remember exactly how it was said, but it was directed to Gloria, and it included the words “old”, “good looking”, and a reference to a 1930’s slang word for a woman.

He took me aside after the guests had left and told me, in that calm, but serious voice (which let you know that he was disappointed in you): “you really hurt grandma’s feelings, and you need to go apologize to her”. With the weight of my grandfather’s disappointment on my shoulders and a knot in my stomach, I apologized. And in that apology, I learned a sense of responsibility for the consequences of my actions, especially when my actions weren’t meant to be hurtful.  Something I reflect on.  Something I carry with me close to my heart.  As I hear stories from friends, family, and neighbors - I realize how important taking responsibility was to him. He felt a duty to do what was right and he felt that others should as well.

Being a man.

Grandpa was big and strong.   I suppose that was the type of man he was, his left a lasting imprint on those he touched.

He wasn’t a perfect man. I don’t know if it’s on account of growing up in a different time or being 20 years in the military, but he was pretty macho. To his detriment, at times. Before this surgery during his hospital stay, he wouldn’t complain about his pain or discomfort until it was obvious to one of us and we would have to get a nurse or doctor.

His stoicism was out of a sense of duty to protect grandma. Unfortunately, it was having the opposite effect, it was making it much harder for her. Luckily, I came prepared for this exact thing — having learned a great lesson from a great man, oh around the age of 7 or 8. To say that I was nervous to talk to my grandfather, my role-model, about something he was doing wrong, was an understatement. I sat with him alone by his bedside, and in the way that he talked to me so many years ago, I explained to him that he had to do better. He looked at me, and nodded, and said “I understand”.

You see, he has taught me that being a man is about being strong, and about having pride, and about protecting those that you love. But, it’s also about knowing when you are wrong and taking responsibility. He taught me that what really makes a man is the desire and commitment to always be a better one than you are. No matter how macho or prideful, he was, he was still the type of man that in his hospital bed, he would hold his 31 year old grandson’s hand while they watched a 49ers game or rooted for the Giants in the World Series. He was the type of man that would sing to his grandchildren,

"I don’t know why she swallowed that fly”.

He was the best man that I have ever known. I will be learning these lessons he taught me for the rest of my life, in hopes that I can follow in his footsteps and be as good of a man as he was.

Goodbye grandpa.

repository: trane/octopress

repo_name: trane/octopress


text:
# Sub-Riemannian-Quantum-Circuits
Implementing quantum circuit geodesic algorithms based on the work of Dr. Michael Nielsen and Michael Swaddle.

Requirements:
- Python version >= 3.7
- Numpy version >= 1.16.2
- Scipy version >= 1.2.1

References:
- Nielsen, Michael, et al. “Optimal Control, Geometry, and Quantum Computing.” Physical Review
A, vol. 73, no. 6, 2006, doi:10.1103/physreva.73.062323.
- Swaddle, Michael. SubRiemannian geodesics and cubics for efficient quantum circuits. 6 Sept. 2017. The University of Western Australia, MPhil thesis. UWA Research Repository, https://research-repository.uwa.edu.au/en/publications/subriemannian-geodesics-and-cubics-for-efficient-quantum-circuits

repository: gkluber/Sub-Riemannian-Quantum-Circuits

gha_language: Python

repo_name: gkluber/Sub-Riemannian-Quantum-Circuits