text:
---
layout: post
title:  "Design Thinking - Human-centric Problem Solving"
date:   2023-07-28 00:00:00 +0000
author: Darren Jones
categories: "Leadership"
tags: "Transformation Design-Thinking"
---

Our world today is driven by fast-paced change and evolving challenges. Finding innovative, scalable solutions to tackle these challenges is becoming a more crucial skill than ever. Design Thinking is a creative approach that places people at the center of problem-solving. By combining empathy, collaboration, and iterative thinking, design thinking transforms how we tackle complex problems and sparks meaningful results.

## Starting with Empathy: Putting People First

Design thinking starts off with empathy – the secret sauce that fuels our understanding of people's needs, desires, and pain points. Through in-depth research, interviews, and observations, we step into the shoes of those affected by the problem, gaining invaluable insights and nurturing a deep sense of empathy.

## From Problems to Opportunities: Shifting Perspectives

Design thinking flips the script on problem-solving by turning challenges into opportunities. By reframing issues, we reveal the underlying needs and aspirations that drive innovation. This shift in perspective opens doors to creative solutions that address root causes rather than just superficial symptoms.

## Ideation: Unleashing Creative Juices

The ideation phase is where creativity takes center stage. Design thinkers cultivate an environment where ideas flow freely, encouraging participants to think outside the box and explore uncharted territory. Through brainstorming sessions, ideation workshops, and creative techniques, they generate a plethora of ideas, no matter how unconventional they may seem.

## Prototyping: Bringing Ideas to Life

Prototyping is where ideas come alive, transforming into tangible representations of potential solutions. Design thinkers employ a variety of tools and techniques, including sketches, wireframes, and interactive mock-ups. These prototypes serve as a canvas for experimentation, testing, and gathering invaluable user feedback.

## Iterate and Improve: Embracing the Learning Curve

Design thinking embraces a "fail-forward" mentality, acknowledging that failure is an integral part of the creative process. Through continuous iteration and refinement, design thinkers learn from mistakes, adapt, and enhance their solutions. Each iteration brings them closer to an optimal outcome, ensuring a solution that truly resonates with users.

## Collaboration: The Symphony of Diverse Perspectives

Design thinking thrives on collaboration, harmonizing diverse talents and viewpoints. Multidisciplinary teams, encompassing various expertise and backgrounds, come together to co-create solutions. This collaborative effort sparks creativity, nurtures innovation, and leads to holistic problem-solving that transcends traditional boundaries.

## User-Centered Solutions: Guided by the User's Needs

At the heart of design thinking lies an unwavering focus on user-centered solutions. Design thinkers prioritize people's needs, desires, and experiences, crafting solutions that deeply resonate. By involving users throughout the process and continually integrating their feedback, design thinkers create impactful, human-centric solutions.

## Conclusion

Design thinking shines as a guiding light in the ever-changing landscape of innovation and problem-solving. It steers us toward a future where empathy, collaboration, and iterative thinking reign supreme. As we embrace this transformative approach, we unlock our creative potential and embark on a journey to address the most complex challenges of our time. With design thinking as our compass, we set sail on a path toward a brighter, more innovative future.


text:
# telepresence-robot-interface

## Project setup
```
npm install
amplify init
amplify add auth
amplify push
amplify add hosting
amplify publish
```

## Configure

Create a file src/config.json:

```json
{
  "endpoint": "< The API Gateway endpoint created by the SAM app >",
  "channelARN": "< The ARN of the signalling channel created by the SAM app >"
}
```

### Compiles and hot-reloads for development
```
npm run serve
```

### Compiles and minifies for production
```
npm run build
```

### Run your tests
```
npm run test
```

### Lints and fixes files
```
npm run lint
```

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

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Third-Party Components

This repository contains the source code and patches for the third-party
libraries:

* DiscUtils (v0.11) - a .NET library for reading and writing ISO files
  and Virtual Machine disk files (VHD, VDI, XVA, VMDK, etc);
* DotNetZip (v<IP_ADDRESS>) - a .NET library for handling ZIP files;
* SharpZipLib (v0.85.4)- a Zip, GZip, Tar and BZip2 library written
  entirely in C# for the .NET platform;
* XML-RPC.NET (v2.5.0) - a library for implementing XML-RPC Services
  and clients in the .NET environment;
* log4net (v2.0.15) - a library providing logging services for purposes
  of application debugging and auditing;
* Json.NET (v13.0.1) - a Json framework for .NET.

## Contributions

The preferable way to contribute patches is to fork the repository on Github and
then submit a pull request. If for some reason you can't use Github to submit a
pull request, then you may send your patch for review to the
<EMAIL_ADDRESS>mailing list, with a link to a public git repository
for review. Please see the [CONTRIB](CONTRIB) file for some general guidelines on submitting
changes.

## License

This code is licensed under the BSD 2-Clause license. The individual libraries
are subject to their own licenses, which can be found in the corresponding
directories. Please see the [LICENSE](LICENSE) file for more information.

## How to build dotnet-packages

### Prerequisites

1. PowerShell 3.0 or above
2. Net Framework 4.5 and 4.8 installed.
3. Net Standard 2.0 installed.
4. Visual Studio build tools for 2019 (toolsversion 16.0).
  Add the location of `msbuild` to the System Path.
5. The Windows 10.0.18362.0 SDK (included in VS 2019).
6. `git`, `patch`, `zip` and `unzip` packages. These can be obtained with
  [Cygwin](https://www.cygwin.com/) or [Chocolatey](https://chocolatey.org).
### Build

The libraries can be built (with patches applied) by opening a PowerShell prompt
in the repo root and running:

```shell
.\build.ps1 [-SnkKey <snk-file>] [-NugetSources <package-sources>]
```

repository: xenserver/dotnet-packages

gha_language: PowerShell

gha_license_id: NOASSERTION

repo_name: xenserver/dotnet-packages


text:
# Watson Developer Cloud Java SDK

[![Build Status](https://travis-ci.org/watson-developer-cloud/java-sdk.svg?branch=master)](https://travis-ci.org/watson-developer-cloud/java-sdk)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.ibm.watson.developer_cloud/java-sdk/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.ibm.watson.developer_cloud/java-sdk)
[![CLA assistant](https://cla-assistant.io/readme/badge/watson-developer-cloud/java-sdk)](https://cla-assistant.io/watson-developer-cloud/java-sdk)

The Java SDK uses the [Watson Developer Cloud][wdc] services, a collection of REST
APIs and SDKs that use cognitive computing to solve complex problems.

## Table of Contents

* [Installation](#installation)
  * [Maven](#maven)
  * [Gradle](#gradle)
* [Usage](#usage)
* [Getting the Service Credentials](#getting-the-service-credentials)
* IBM Watson Services
  * [Alchemy Language](alchemy)
  * [Alchemy Vision](alchemy)
  * [Alchemy Data News](alchemy)
  * [Concept Insights](alchemy)
  * [Conversation](conversation)
  * [Dialog](dialog)
  * [Discovery](discovery)
  * [Language Translation](language-translation)
  * [Language Translator](language-translator)
  * [Natural Language Classifier](natural-language-classifier)
  * [Natural Language Understanding](natural-language-understanding)
  * [Personality Insights](personality-insights)
  * [Retrieve and Rank](retrieve-and-rank)
  * [Speech to Text](speech-to-text)
  * [Text to Speech](text-to-speech)
  * [Tone Analyzer](tone-analyzer)
  * [Tradeoff Analytics](tradeoff-analytics)
  * [Visual Recognition](visual-recognition)
* [Changes for v4.0](#changes-for-v40)
* [Using a Proxy](#using-a-proxy)
* [Android](#android)
* [Running in IBM Cloud](#running-in-ibm-cloud)
* [Default Headers](#default-headers)
* [Debug](#debug)
* [Eclipse and Intellij](#working-with-eclipse-and-intellij-idea)
* [License](#license)
* [Contributing](#contributing)

## Installation

##### Maven

All the services:

```xml
<dependency>
	<groupId>com.ibm.watson.developer_cloud</groupId>
	<artifactId>java-sdk</artifactId>
	<version>4.2.1</version>
</dependency>
```

Only Retrieve and Rank:

```xml
<dependency>
	<groupId>com.ibm.watson.developer_cloud</groupId>
	<artifactId>retrieve-and-rank</artifactId>
	<version>4.2.1</version>
</dependency>
```

##### Gradle

All the services:

```gradle
'com.ibm.watson.developer_cloud:java-sdk:4.2.1'
```

Only Retrieve and Rank:

```gradle
'com.ibm.watson.developer_cloud:retrieve-and-rank:4.2.1'
```

Only Visual Recognition:

```gradle
'com.ibm.watson.developer_cloud:visual-recognition:4.2.1'
```

##### Development Snapshots

Snapshots of the development version are available in [Sonatype's snapshots repository][sonatype_snapshots].

###### Gradle

Add repository to your project Gradle file

```gradle
allprojects {
    repositories {
        maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
    }
}
```

And then reference the snapshot version on your app module gradle
Only Speech to Text:

```gradle
'com.ibm.watson.developer_cloud:speech-to-text:3.8.1-SNAPSHOT'
```

##### JAR

Download the jar with dependencies [here][jar].

Now, you are ready to see some [examples](https://github.com/watson-developer-cloud/java-sdk/tree/master/examples/src/main/java/com/ibm/watson/developer_cloud).

## Usage

The examples within each service assume that you already have service credentials. If not,
you will have to create a service in [IBM Cloud][ibm_cloud].

If you are running your application in IBM Cloud (or other platforms based on Cloud Foundry), you don't need to specify the
credentials; the library will get them for you by looking at the [`VCAP_SERVICES`][vcap_services] environment variable.

## Getting the Service Credentials

You will need the `username` and `password` (`api_key` for AlchemyAPI) credentials, and the API endpoint for each service. Service credentials are different from your IBM Cloud account username and password.

To get your service credentials, follow these steps:

1. Log in to [IBM Cloud](https://console.bluemix.net/catalog?category=watson)

1. Create an instance of the service:
    1. In the IBM Cloud **Catalog**, select the service you want to use.
    1. Click **Create**.

1. Copy your credentials:
    1. On the left side of the page, click **Service Credentials**, and then **View credentials** to view your service credentials.
    1. Copy `url`, `username` and `password`(`api_key` for AlchemyAPI or Visual Recognition).

## Changes for v4.0
Version 4.0 focuses on the move to programmatically-generated code for many of the services. See the [changelog](https://github.com/watson-developer-cloud/java-sdk/wiki/Changelog) for the details.

## Migration
This version includes many breaking changes as a result of standardizing behavior across the new generated services. Full details on migration from previous versions can be found [here](https://github.com/watson-developer-cloud/java-sdk/wiki/Migration).

## Android

The Android SDK utilizes the Java SDK while making some Android-specific additions. This repository can be found [here](https://github.com/watson-developer-cloud/android-sdk). It depends on [OkHttp][] and [gson][].

## Using a Proxy

Override the `configureHttpClient()` method and add the proxy using the `OkHttpClient.Builder` object.

For example:

```java
ConversationService service = new ConversationService("2017-05-26") {
  @Override
  protected OkHttpClient configureHttpClient() {
    Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxyHost", 8080));
    return super.configureHttpClient().newBuilder().proxy(proxy).build();
  }
};

service.setUsernameAndPassword("<username>", "<password>");

WorkspaceCollectionResponse workspaces = service.listWorkspaces(null, null, null, null).execute();
System.out.println(workspaces);
```

For more information see: [OkHTTPClient Proxy authentication how to?](https://stackoverflow.com/a/35567936/456564)

## Running in IBM Cloud

When running in IBM Cloud (or other platforms based on Cloud Foundry), the library will automatically get the credentials from [`VCAP_SERVICES`][vcap_services].
If you have more than one plan, you can use `CredentialUtils` to get the service credentials for an specific plan.

```java
PersonalityInsights service = new PersonalityInsights();
String apiKey = CredentialUtils.getAPIKey(service.getName(), CredentialUtils.PLAN_STANDARD);
service.setApiKey(apiKey);
```

## Default Headers

Default headers can be specified at any time by using the `setDefaultHeaders(Map<String, String> headers)` method.

The example below sends the `X-Watson-Learning-Opt-Out` header in every request preventing Watson from using the payload to improve the service.

```java
PersonalityInsights service = new PersonalityInsights();

Map<String, String> headers = new HashMap<String, String>();
headers.put(HttpHeaders.X_WATSON_LEARNING_OPT_OUT, 1);

service.setDefaultHeaders(headers);

// All the api calls from now on will send the default headers
```

## Specifying a service URL

You can set the correct API Endpoint for your service calling `setEndPoint()`.

For example, if you have the conversation service in Germany, the Endpoint may be `https://gateway-fra.watsonplatform.net/conversation/api`.

You will need to call

```java
Conversation service = new Conversation("<version-date>");
service.sentEndPoint("https://gateway-fra.watsonplatform.net/conversation/api")
```

## 401 Unauthorized error

Make sure you are using the service credentials and not your IBM Cloud account/password.
Check the API Endpoint, you may need to update the default using `setEndPoint()`.

## Debug

HTTP requests can be logging by adding a `loggging.properties` file to your classpath.

```none
handlers=java.util.logging.ConsoleHandler
java.util.logging.ConsoleHandler.level=FINE
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s %4$s: %5$s%n
.level=SEVERE
# HTTP Logging - Basic
com.ibm.watson.developer_cloud.util.HttpLogging.level=INFO
```

The configuration above will log only the URL and query parameters for each request.

For example:

```none
Mar 30, 2017 7:31:22 PM okhttp3.internal.platform.Platform log
INFO: --> POST https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=false http/1.1 (923-byte body)
Mar 30, 2017 7:31:22 PM okhttp3.internal.platform.Platform log
INFO: <-- 200 OK https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=false (104ms, unknown-length body)
Mar 30, 2017 7:31:23 PM okhttp3.internal.platform.Platform log
INFO: --> POST https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=true http/1.1 (12398-byte body)
Mar 30, 2017 7:31:35 PM okhttp3.internal.platform.Platform log
INFO: <-- 200 OK https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=true (12311ms, unknown-length body)
```

**Warning:** The logs generated by this logger when using the level `FINE` or `ALL` has the potential to leak sensitive information such as "Authorization" or "Cookie" headers and the contents of request and response bodies. This data should only be logged in a controlled way or in a non-production environment.

## Build + Test

To build and test the project you can use [Gradle][] (version 1.x).

Gradle:

```sh
cd java-sdk
gradle jar  # build jar file (build/libs/watson-developer-cloud-4.2.1.jar)
gradle test # run tests
gradle check # performs quality checks on source files and generates reports
gradle testReport # run tests and generate the aggregated test report (build/reports/allTests)
gradle codeCoverageReport # run tests and generate the code coverage report (build/reports/jacoco)
```

## Working with Eclipse and Intellij IDEA

If you want to work on the code in an IDE instead of a text editor you can
easily create project files with gradle:

```sh
gradle idea     # Intellij IDEA
gradle eclipse  # Eclipse
```

## Open Source @ IBM

Find more open source projects on the [IBM Github Page](http://ibm.github.io/)

## License

This library is licensed under Apache 2.0. Full license text is
available in [LICENSE](LICENSE).

## Contributing

See [CONTRIBUTING.md](.github/CONTRIBUTING.md).

## Code of Conduct

See [CODE_OF_CONDUCT.md](.github/CODE_OF_CONDUCT.md).

### Other

If you are having difficulties using the APIs or you have a question about the IBM
Watson Services, please ask a question on
[dW Answers](https://developer.ibm.com/answers/questions/ask/?topics=watson)
or [Stack Overflow](http://stackoverflow.com/questions/ask?tags=ibm-watson).

[wdc]: http://www.ibm.com/watson/developercloud/
[ibm_cloud]: https://console.bluemix.net
[Gradle]: http://www.gradle.org/
[OkHttp]: http://square.github.io/okhttp/
[gson]: https://github.com/google/gson
[apache_maven]: http://maven.apache.org/
[sonatype_snapshots]: https://oss.sonatype.org/content/repositories/snapshots/com/ibm/watson/developer_cloud/
[vcap_services]: https://docs.run.pivotal.io/devguide/deploy-apps/environment-variable.html#VCAP-SERVICES

[jar]: https://github.com/watson-developer-cloud/java-sdk/releases/download/java-sdk-4.2.0/java-sdk-4.2.1-jar-with-dependencies.jar

repository: viannaandreBR/java-sdk

branch_name: refs/heads/develop

gha_language: Java

repo_name: viannaandreBR/java-sdk


text:
# 1. Towards less blocking pastures

```ignore
last-edited: 2019-11-11
rustc-version: rustc 1.40.0-nightly (b520af6fd 2019-11-03)
```

So what's the deal here? Why do we need asynchronous Rust in the first place?

In my experience, more often than not, the first answers to come up are along the lines of "to workaround the limitations of synchronous I/O".
I'm not a big fan of this answer; while async I/O is undoubtedly the poster child of all async applications, I reckon it is still just that: _an_ application, out of many.

In particular, async I/O is a very tricky beast that brings with it A) its own set of very specific problems and B) a gazillon of moving pieces that have nothing to do with Rust's async primitives per-se.
For these reasons, I'd like to instead try and approach the matter from a different, and perhaps more familiar angle: start from the beginning with iterators and closures, and see where that takes us.
Of course, we'll cover async I/O when the time is right.

Now I'm sure that opening a book about asynchronous Rust with a whole chapter dedicated to iterators and closures might seem like a dubious choice but, as we'll see, iterators, closures, streams & futures are all very much alike in crucial ways.
In fact, I simply cannot fathom how we'd go about demystifying asynchronous Rust without first lifting all of the magic behind iterators and closures. That might just be me, though.

Hence in this first chapter, we'll do just that, demystify iterators and closures:
- What they are and what they're not.
- Their memory representation and execution model.
- Their interesting similarities.
- And last but not least: why would we need and/or want something else to begin with?

license: MIT

repository: bkolad/rust-async

repo_name: bkolad/rust-async


text:
{
  "date" : "2021-08-27",
  "keywords" : [ "wsh file", "wsh file format", "what is a wsh file", "file", "wsh example", "wsh file extension","extension", "format" ],
  "author" : {
    "display_name" : "Muhammad Umar"
  },
  "draft" : "false",
  "toc" : true,
  "description":"Learn about WSH file format and APIs that can create and open WSH files.",
  "title" : "WSH - Windows Script File",
  "linktitle" : "WSH",
  "menu" : {
    "docs" : {
      "parent" : "executable"
    }
  },
  "lastmod" : "2021-08-27"
}

## What is a WSH file?
A file with .wsh extension contains properties and parameters for a certain programming language script such as VB or VBS etc. The actual need of WSH is to use them for customizing the execution of certain scripts. WScript or CScript are required to run and both of these are included with the Windows operating system. WSH files were initially provided on Windows 95 on the installation discs as an optional configurable and installable for the Control Panel, and then a default component of Windows 98.

## WSH file format
WSH (Windows Script Host) may be used for a various purposes, including administration, logon scripts and general automation. WSH establishes an environment for scripts to run. it invokes the suitable script engine and allocate a set of services and objects for the script to work with. These scripts can be run in GUI mode, from a COM object or command line mode, providing flexibility to the user for both interactive or non-interactive scripts.

### Examples
Here is very simple example which shows some VBScript which uses the root WSH COM object "WScript" to display a message with an 'OK' button. When this script will be launched the CScript or WScript engine would be called and the runtime environment will be established.

```
WScript.Echo "Hello world"
WScript.Quit
```

## References

* [Windows Script Host - by Wikipedia](https://en.wikipedia.org/wiki/Windows_Script_Host)

gha_language: Mathematica

gha_license_id: MIT


text:
# TostSerializer
[![Build Status](https://travis-ci.org/pharo-ide/TostSerializer.svg?branch=master)](https://travis-ci.org/pharo-ide/TostSerializer)

TostSerializer is general object serialization library which allows you to transfer objects over binary streams.

Tost is abbreviation from "Transient Objects Transport" where transient transport means that resulted binary data is supposed to be used in time. Tost does not put any meta information on streams and does not support versioning and data migration.

Its goal is to provide a compact and an efficient way for objects serialization with ability to be optimized for concrete application usage.

repository: oliveiraallex/TostSerializer

repo_name: oliveiraallex/TostSerializer


text:
# S_m field (SearchAThing.Sci.ElectricalConductivity)
(No Description)

## Signature
```csharp
public static readonly MeasureUnit S_m;
```


text:
# How to add NPCs

The first step in making a custom NPC is to add an additional NPC to the ```data\npcs.txt``` file found in the unpacked game data. First, the NPC must be named; NPCs in game are named based on order of appearance, and race. Skeleton NPCs are named ```NPCx``` (where ```x``` is a unique number to differentiate them), Light Blob NPCs are named ```NPCBx```, Ghosts are named ```NPCGx```, Dark Blobs are named ```NPCDx```, cameos such as Steven and Isaac, from Edmund's other games are named ```NPCXx```, and finally the large Stevens that transport Ash to the future are named ```NPCHx```. Therefore custom NPCs should use a unique naming scheme, such as ```NPCAx```, to prevent your mod from editing and conflicting with in-game NPCs.

The basic description, such as ```#basic sideways``` that appears below the name has no effect and is used to identify NPCs.

The ```movieclip``` decides what form your custom NPC takes.
```sound_id``` is similar, and decides the noises your NPC makes when it's dialogue activates. These are fairly descriptive, such as ```NPCSkull``` making a bone-rattling noise when spoken to. Generally, the ```sound_id``` should match the ```movieclip```.

The ```text``` decides what your custom NPC says when spoken to. Each set of double-quotes ```""``` is a separate box of text that appears in sequence. The new-line character ```\n``` makes the text after it start on a new line. Text should be surrounded by square brackets ```[]```, and dont forget to add curly brackets ```{}``` brackets around your NPC's code, or else an error will occur when you enter the level.

Here is an example of what an NPC entry could look like when complete:

```plaintext
NPC0 {
    #basic sideways
    movieclip NPC0
    sound_id NPCSkull
    text [
        "oh \n . . . \n its you. . ."
        "must be nice \n being alive \nn' all that"
        "when i died \n that tumor wiggled out"
        "it's been floating \n up there for years \n watching me"
        "please\n dont take it. . . \n its all i have left"
    ]
}
```

To add your NPC to a level, you must add your NPC to the level's ```data\tilesets.txt``` code. The NPC's name should be written after ```npc_1```, ```npc_2``` or ```npc_3```. Then, add your npc to the level using the level editor; NPCs are found in tiles Z1 - 3 in the editor, in order of number. See the [Tile Reference](../reference/tiles.md) for more information on these particular tiles.

After finishing the [Getting Started / Tutorials](./getting_started.md) section, please see the [Modding Reference](../reference/reference.md) and particularly the NPCs section for more information on the possible values and details regarding custom NPCs.

gha_language: HTML


text:
Welcome to ngx-electronify 👋

> Angular CLI builder that runs your application in the desktop using Electron

The builder runs your Angular application in `serve` mode and loads it in an Electron window. Notice that the builder currently assumes that you are serving your application on the default port 4200.

### 🏠 [Homepage](https://github.com/bampakoa/ngx-electronify)

## Install

```sh
ng add ngx-electronify
```
You can pass the following options:
* `--project`: the name of the project on which you want to install it. It is useful in multi-project workspaces such as Nx DevTools.
* `--configuration`: the configuration of the workspace. By default it uses the development configuration.

## Usage

```sh
ng run [project-name]:desktop
```

## Author

👤 **Aristeidis Bampakos**

* Website: http://www.medium.com/@abampakos
* Twitter: [@abampakos](https://twitter.com/abampakos)
* Github: [@bampakoa](https://github.com/bampakoa)

## 🤝 Contributing

Contributions, issues and feature requests are welcome!
Feel free to check [issues page](https://github.com/bampakoa/ngx-electronify/issues).

## Show your support

Give a ⭐ if this project helped you!


text:
# "Black Coffee" Cafe Analog Color Scheme

Atom syntax theme inspired by the official design guidelines for the student-run Cafe Analog @ The IT-University of Copenhagen.

![screenshot](cafe_analog_color_scheme.png)


text:
# uSH: a small shell
## Written by Noah Brecht

*Pronounced micro-shell!*

A micro-shell for the Linux OS. It supports I/O piping and has a few builtins. It is considerably smaller that bash, zsh, etc.
It also has no dependencies, making it extremely portable.

## Build Process

The build process is extremely simple:

**Clean the source tree:**
`make clean`

**Compile uSH:**
`make`

**Install:**
`sudo make install`

## Dependencies
**Required**
- `make`
- `gcc`
- `ld` (provided with gcc)
- `strip`

**Optional**
- `gdb` (for debugging the shell)
- `valgrind` (for finding memory leaks)

The Makefile installs uSH as /bin/ush by default. Change the value of $INSTALLDIR and $INSTBIN to change that location.

# Syntax

Run a single command:
`:? <command> <arguments>`
Pipe multiple commands together:
`:? <command1> <arg1> | <command2> <arg2>`
Run a system command with the same name as a builtin command:
`:? <command>^ <arguments>`
Variables can be used on the command line:
`:? $I_Am_A_Command $I_Am_An_Argument`
Variables can be assigned on the command line:
`:? $var = value`

# Command-Line Options

`--version`: Print shell version information
`--help`: Print shell help text
`--buffer <val>`: Set the buffer size of the shell
`--script <file>`: Execute commands from a script


text:
# Ease of notation

The following terms introduce a nicer notation for some operations, for example using the ∈ operator, $p ∈ \mathcal M$, to determine whether $p$ is a point on the [`AbstractManifold`](https://juliamanifolds.github.io/ManifoldsBase.jl/stable/types.html#ManifoldsBase.AbstractManifold)  $\mathcal M$.

````@docs
in
TangentSpace
````

# Fallback for the exponential map: Solving the corresponding ODE

When additionally loading [`NLSolve.jl`](https://github.com/JuliaNLSolvers/NLsolve.jl) the following fallback for the exponential map is available.

```@autodocs
Modules = [Manifolds]
Pages = ["nlsolve.jl"]
Order = [:type, :function]
```

# Public documentation

The following functions are of interest for extending and using the [`ProductManifold`](@ref).

```@docs
submanifold_component
submanifold_components
ProductRepr
```

## Specific exception types

For some manifolds it is useful to keep an extra index, at which point on the manifold, the error occurred as well as to collect all errors that occurred on a manifold. This page contains the manifold-specific error messages this package introduces.

```@autodocs
Modules = [Manifolds]
Pages = ["errors.jl"]
Order = [:type, :function]
```

gha_language: Julia


text:
# Node.js HTTP Port Guard

Wrap a server "start" function in asynchronous checks for port availability.
Fail if the port is already in use prior to function execution or if the port
does not become utilized after execution.

The only reliable way to determine if a server process has started successfully
is to poll the port it has been assigned. If this port is already in use\*, the
child process will fail to start, but the current process will consider the
operation a success. This invalidates the `kill` function created by this
module and will likely lead to errors during test cleanup.

\* This condition will most commonly be caused by a zombie server instance
   erroneously created in some prior test run.

## API

This module exposes a single function that accepts two arguments: the desired
port and a function that is expected to bind to that port (the actual binding
may take place in another process). This function should return a `kill`
callback function that kills the server

```js
var portGuard = require('http-port-guard');

portGuard(8000, function() {
  var app = startMyApp();

  return app.destroy;
}).then(function(kill) {
  console.log('Application is now available on port 8000!');

  console.log('Now destroying application.');
  kill();
});
```

If the second argument is an object, it will be interpreted as an "options"
object, and the following properties will be honored:

- `host` - {string} - Host name of the server to poll. Defaults to 'localhost'
- `retryPeriod` - {string} - number of milliseconds to wait between port polling
  operations; defaults to 100
- `retryCount` - {string} - number of polling failures to tolerate before
  considering the operation a failure; defaults to 100
- `Promise` - {Function} - Promise A/+ constructor; defaults to
  globally-defined Promise

The function resutns a Promise that is rejected if the port is already in use
or if requests to the specified port fail after startup. It is resolved with
the `kill` callback function provided by `startFn`.

## License

Copyright (c) 2015 Mike Pennisi
Licensed under the MIT license.

repository: jugglinmike/node-http-port-guard

repo_name: jugglinmike/node-http-port-guard


text:
# Image Processing Algorithms

This folder contains an assortment of different image processing algorithms. I have added them all in case we need to use them during the processing of SUAS images.

The list of algorithms demonstrated:

1. ROF (Rudin-Osher-Fatemi) de-noising model
2. Sobel & Gaussian X and Y derivative identification -- Preprocessing technique
3. Gaussian Blurring -- Preprocessing technique
4. Histogram Equalization -- Preprocessing technique
5. Image Averaging -- Preprocessing technique
6. PCA (Principal Component Analysis) -- Preprocessing technique

repository: peterhusisian/SUAS-Competition

repo_name: peterhusisian/SUAS-Competition


text:
Disk Image Loader
=================

A while ago I obtained an SCSI2SD interface for some of my vintage synthesizers.
It can emulate several drives with just one SD card, which is a feature I wanted
to take advantage of. I formatted an SD card to contain three partitions for raw
AKAI / Roland / Kurzweil CD images and a partition to be used as a FAT-formatted
hard drive. It is trivial to "mount" new CD images using Linux by using the "dd"
command, but Windows has no built-in tools to do this directly.

I decided to write a simple GUI tool which directly writes up to three CD images
to specified sectors on the SD card. Windows can only handle one partition on SD
cards, so I recommend to first partition the SD card using gparted on Linux, and
obtain the sector offsets to use with this tool from there.

A word of caution
-----------------

This tool directly manipulates the physical device and does not work on device
volumes - they are only displayed in the UI for determining the physical device
they belong to. There are practically no safe-guards, so choosing the wrong
device can cause irreversibly damage to your file system. This is one reason why
I am not providing pre-compiled binaries for this project.

Configuration file
------------------

A configuration file called `config.json` can be placed in the same directory as
the executable, containing the default volume name to look for and the default
offsets (in 512-byte sectors) to copy the images to. An example JSON file might
look like this:

```
{
  "default_volume":"XV-5080",
  "offset1":"3655680",
  "offset2":"5007360",
  "offset3":"6359040"
}
```

Dependencies
------------

Disk Image Loader is written in C++ using Visual Studio 2015. Since it uses
low-level disk access, it doesn't make a lot of sense to support any other
compilers or operating systems.

Disk Image Loader has the following external dependencies:

 -  Qt 5 (https://www.qt.io/download/)

Contact
-------

Disk Image Loader was created by Johannes Schultz.
You can contact me through my websites:
 -  https://sagagames.de/
 -  https://sagamusix.de/

repository: drkzrg/DiskImageLoader

repo_name: drkzrg/DiskImageLoader


text:
# Sotu2014

A data analysis of what happened minute by minute on Twitter during the
State of the Union Address of 2014

## Libraries used

 * MooTools (MIT license)
 * JavaScript InfoVis Toolkit (MIT license)
 * d3 (MIT license)

## Authors

 * [philogb](https://twitter.com/philogb)

## Using Gnip
/data/gnip

## Steps

 * Turn on the Tweet consumption tool (5:30).
 * Replace the speech with the new one. Do this in local copy and in
    interactiveprod (push interactiveprod)
 * Export the added Tweets in the table as tsv
 * Run the tsv2json script, then the data-tweets script from grunt
 * Export the timestamps into the local repo

repository: twitter/interactive

branch_name: refs/heads/gh-pages

gha_language: ApacheConf

repo_name: twitter/interactive


text:
_[Idean][main-url] is a global design agency dedicated to delivering the best possible User Experience._

Levi used JavaScript to create awesome user experiences across many different projects for many different clients. Unfortunately, all of the projects he worked on are under NDAs, so he cannot disclose too much detail about any of them.

### Project A: Enterprise Security-Management Application

Levi developed a high-fidelity prototype for the client’s enterprise security-management application. This included an AngularJS framework with an intricate frontend routing mechanism.

_Front and back end: Node.js, AngularJS, MongoDB, Gulp, SASS_

### Project B: Enterprise Storage-Management Application

Levi developed a first-iteration of the frontend for the client's enterprise storage-management application. This included a complex SVG-based workspace in which resources were graphically configured within tree structures.

_Front end: AngularJS, Gulp, SVG, SASS_

### Project C: Analytics Dashboard

Levi developed a web portal for analyzing data collected from mobile applications. This included highly configurable data visualizations.

_Front end: AngularJS, D3.js, Gulp, SASS_

### Project D: Web Portal for SDK Specifications

Levi developed a web portal for displaying the specifications of the client's RESTful API. This included the ability to test out and tweak each of the different API calls directly from the portal. Levi also created a simple test server for handling the requests.

_Front and back end: Node.js, AngularJS, MongoDB, Gulp, SASS_

### Project E: Checkout Wizard

Levi helped develop a complex checkout wizard system for the client's translation service. This involved many custom widgets for each page in addition to complex routing logic. This also required interfacing with server APIs to update the quote data after each step.

_Front end: AngularJS, Gulp, SASS_

### Project E: Content Management System

Levi developed the full-stack infrastructure for a content management system.

_Front and back end: Node.js, AngularJS, MongoDB, Grunt, SASS_

### Project F: WordPress site

Levi updated and maintained the client's pre-existing WordPress website.

### Project G: Squarespace site

Levi customized the client's pre-existing Squarespace website.

[main-url]: http://idean.com

repository: levilindsey/hex-grid

gha_language: JavaScript

repo_name: levilindsey/hex-grid


text:
# Hasi
[![forthebadge](https://forthebadge.com/images/badges/built-by-developers.svg)](https://forthebadge.com)
[![forthebadge](https://forthebadge.com/images/badges/built-for-android.svg)](https://forthebadge.com)
[![forthebadge](https://forthebadge.com/images/badges/built-with-love.svg)](https://forthebadge.com)
[![forthebadge](https://forthebadge.com/images/badges/check-it-out.svg)](https://forthebadge.com)
[![forthebadge](https://forthebadge.com/images/badges/just-plain-nasty.svg)](https://forthebadge.com)
[![forthebadge](https://forthebadge.com/images/badges/made-with-java.svg)](https://forthebadge.com)

Hasi is an Android Application that utilizes the Google Vision Application Programming Interface (API) to predict the
happiness of a person which is ascertained whether the person is smiling or not. This is achieved using Classification which is determined if a certain facial characteristic is present.

## Concept Behind Vision API

A landmark is a point of interest within a face. The left eye, right eye, and nose base are all examples of landmarks. The figure below shows some examples of landmarks:

![image](https://developers.google.com/vision/images/landmarks.jpg)

Rather than first detecting landmarks and using the landmarks as a basis of detecting the whole face, the Face API detects the whole face independently of detailed landmark information. For this reason, landmark detection is an optional step that could be done after the face is detected. Landmark detection is not done by default, since it takes additional time to run. You can optionally specify that landmark detection should be done.

Classification determines whether a certain facial characteristic is present. The Android Face API currently supports two classifications: eyes open and smiling. Classification is expressed as a certainty value, indicating the confidence that the facial characteristic is present. For example, a value of 0.7 or more for the smiling classification indicates that it is likely that a person is smiling.

Both of these classifications rely upon landmark detection.

Also note that “eyes open” and “smiling” classification only works for frontal faces, that is, faces with a small Euler Y angle (at most about +/- 18 degrees).

## Creating a Face Detector

A face detector is created in the onCreate method of the app’s main activity.

Note that facial landmarks are not required in detecting the face, and landmark detection is a separate (optional) step. By default, landmark detection is not enabled since it increases detection time. We enable it here in order to visualize detected landmarks.

Given a bitmap, we can create Frame instance from the bitmap to supply to the detector:

```java
Frame frame = new Frame.Builder().setBitmap(bitmap).build();
```

The detector can be called synchronously with a frame to detect faces:

```java
SparseArray<Face> faces = detector.detect(frame);
```
The result returned includes a collection of Face instances. We can iterate over the collection of faces, the collection of landmarks for each face, and draw the result based on each landmark position:

```java
for (int i = 0; i < faces.size(); ++i) {
    Face face = faces.valueAt(i);
    for (Landmark landmark : face.getLandmarks()) {
        int cx = (int) (landmark.getPosition().x * scale);
        int cy = (int) (landmark.getPosition().y * scale);
        canvas.drawCircle(cx, cy, 10, paint);
    }
}
```

## References

[Google Developers](https://developers.google.com/)<br>
[Google Codelabs](https://codelabs.developers.google.com/)

## LICENSE

This project is licensed under the Apache-2.0 License - see the [LICENSE](https://github.com/HarshCasper/Hasi/blob/master/LICENSE) file for details.

repository: HarshCasper/Hasi

repo_name: HarshCasper/Hasi


text:
---
layout: text/textblock-no-nav
---

This privacy statement is about [guides.service.gov.au](http://guides.service.gov.au) — this is an online service managed by the Digital Transformation Agency (DTA). The DTA is located in Canberra, Australia.

The [Digital Transformation Agency privacy policy](https://www.dta.gov.au/privacy-statement/) describes how we handle your personal information.

We respect and protect the privacy of our users.

We are committed to meeting the highest standards when we collect, store, use and disclose your personal information.

This DTA website is bound by the [Commonwealth Privacy Act 1988](https://www.legislation.gov.au/Series/C2004A03712), including the Australian Privacy Principles contained in the Privacy Act.

repository: govau/service-manual

repo_name: govau/service-manual


text:
# OpenStreetMap tile server for ExploreSC
This repository contains a customized docker image of the OpenStreetMap tile server, used for the [ExploreSC](https://github.com/DigitalUSSouth/ExploreSC) mobile app. The map only contains detailed data for South Carolina, but it may be expanded easily to cover a wider area.

## Usage
- Download shapefiles
```cd osm/openstreetmap-carto-2.41.0 && ./get-shapefiles.sh```
- Build the docker image
```docker build -t exploresc-tileserver:1 . ```
- Run container on port 3000
```docker run -dit --name exploreSCtileserver -p 3000:80 exploresc-tileserver:1```

After starting the container, tiles will be available at http://localhost:3000/osm_tiles/0/0/0.png

## License
BSD 3-clause - ***Note:*** This license covers only the top-level docker code (Dockerfile, scripts at the top level, etc. ). Files/projects under the ```osm``` directory are covered by their own respective licenses. See included licenses in each directory.

repository: DigitalUSSouth/ExploreSC-openstreetmap

repo_name: DigitalUSSouth/ExploreSC-openstreetmap


text:
# Release v0.119.0

## 🚀 Features

- Add resolve conflicts option on addon create (#5880)

## 🎯 Improvements

- Improve error message when Fargate is unsupported in an AZ (#5875)

## 🐛 Bug Fixes

- Fix setting cluster DNS for managed Ubuntu (#5889)
- Fix AWS auth when \`AWS\_PROFILE\` is set (#5854)
- Make AMI Bottlerocket value case insensitive (#5852)

## 🧰 Maintenance

- Fix publish-docs workflow (#5901)
- Remove dependency on k8s.io/legacy-cloud-providers (#5899)
- Upgrade vulnerable dependencies (#5890)

## 📝 Documentation

- Updates to additional volumes mapping section and docs theme (#5885)

## Acknowledgments
Weaveworks would like to sincerely thank:
@faraazkhan

repository: spotinst/weaveworks-eksctl

branch_name: refs/heads/feat-spot-ocean

gha_language: Go

repo_name: spotinst/weaveworks-eksctl


text:
# Future DateTime UTC timestamps

If you are certain that all of your timestamps are in the past, then you can
safely ignore this guide.

If you are working with timestamps that are in the future, and those timestamps
are inside countries with governing bodies that have the ability to change
timezone rules, including daylight savings, then you may want to consider your
timestamp storage strategy. Shortly, it's not foolproof to convert the timestamp
to UTC and store only that DateTime.

## Rules Change

Consider this scenario: It's currently year 2019 and you receive a timestamp for
a user located in Washington, USA for July 4, 2022. You convert it to UTC and
store it in your database.

Today (in year 2019), Washington state recognizes Daylight Savings Time and it
shifts back and forth an hour over the year. Since the timestamp is in the
summer, it's shifted forward an hour.

In 2020, Washington enacts a new law that declares that they will no longer be
participate in Daylight Savings Time; meaning it's always shifted back one
hour year-round.

You've already stored your timestamps in the future converted to UTC using the
old rules. How do you know to fix all your timestamps in your database for users
in Washington state?

## What is our context?

There are 3 elements at play:

1. You need a consistent timestamp field for database queries (opposed to
   strings). Usually this is UTC timestamps.
2. The user provided a timestamp based on their location, and looked at the
   clock on their desk when filling in the form in your web app.
3. The provided timestamp is based on the location the user is in, and that
   location follows a set of rules of how time changes throughout the year.

We need to store timestamps in a database column made for timestamps so we can
achieve #1. This can be more complicated given your database, but using Postgres
as an example, it internally converts to UTC and queries against that. If you're
using Ecto as your data mapper, it must always be in UTC before storage.

If the law changes between now and the future timestamp, we've lost the correct
wall time for the user in #2.

When we immediately convert to UTC, we lose the context in #3.

## Storage Strategy

Store the user's provided timestamp and timezone separately from the converted
UTC. For example:

```elixir
field :my_timestamp_utc, :utc_datetime
field :my_timestamp_tz, :string
field :my_timestamp_wall, :naive_datetime
```

Since we're making `my_timestamp_utc` a `:utc_datetime`, we are affirming we
have the timezone information of UTC. Since we're making `my_timestamp_wall` a
`:naive_datetime`, we're affirming we do not have the timezone.

Once you have these 3 pieces of context, you can periodically update and verify
changes. It would be good to update your UTC timestamps whenever your tzdata
files are updated. If the walltime + timezone is reconverted to UTC and is
different from your stored UTC timestamp, then you know the rules have changed
since storage. Update the UTC timestamp and perhaps notify the customer to
ensure the intentions are still correct (for example, did they already know of
the upcoming law change and anticipate it?).

## Credits

[http://www.creativedeletion.com/2015/03/19/persisting_future_datetimes.html](http://www.creativedeletion.com/2015/03/19/persisting_future_datetimes.html)

gha_language: Elixir


text:
---
title:        "What is your product strategy"
path:         "what-is-your-product-strategy"
date:         "2018-09-23"
description:  "Most companies do not have a coherent product strategy"
---

## Overview
Having a clear, simple product strategy will help you build the right
features. Otherwise, you are going to spend a lot of time building things
that will not drive your business.

## Code
Do not forget to add the code. Here is some `inline code`, dude.

```javascript
foreach i in array {
  print "Counter = ${i}"
}
```
## Working with Robots
Here is a picture of a cute robot.

repository: mcdaley/blooger-bootstrap

repo_name: mcdaley/blooger-bootstrap


text:
# Solarized UI-Colorscheme for IntelliJ IDEA

The purpose of this project is to adapt the IntelliJ UI to the solarized color scheme.

This project is inspired by the original solarized colour scheme developed by [Ethan Schoonover] and the IntelliJ IDEA colour scheme maintained in the [IntelliJ-only repository]. For more information about the Solarized scheme, for screenshots, details and colour scheme versions for different editors and other applications visit the [Solarized homepage]. Most of these versions can be found in the main [Solarized repository] on GitHub.

[Nathan Schwermann] had the same approach to adapt the IntelliJ UI to the solarized scheme. He shared it in his personal [Gist]. In Contrast to his script this project tries to address the light and the dark scheme and is fitted to the newest IntelliJ version.

[Ethan Schoonover]<EMAIL_ADDRESS>[Nathan Schwermann]<EMAIL_ADDRESS>[Solarized homepage]: <http://ethanschoonover.com/solarized>
[Solarized repository]: <https://github.com/altercation/solarized>
[IntelliJ-only repository]: <https://github.com/jkaving/intellij-colors-solarized>
[Gist]: <https://gist.github.com/schwiz/5593723>

## Contents

- [Status](#status)
- [Known Issues](#known-issues)
- [Installation](#installation)
- [Contributing](#contributing)

## Status

Until now, it is not possible to provide custom themes for the IntelliJ IDEA UI. To get around this limitation it is possible to edit the existing themes directly by manipulating the property files inside the _idea.jar_ container. Unfortunately it is not possible to adapt all properties of the UI and therefore some colours stay as they are defined by the base theme.

These colour theme files are primarily tested with the latest version of IntelliJ IDEA Community and Ultimate Edition.

## Installation

Because the customization of the IntelliJ UI is not supported by Jetbrains, it is necessary to modify the IntelliJ files directly by changing the content of the _idea.jar_. This file can be found in the application folder of your IntelliJ IDEA installation. It is located inside the _lib_ directory.

To make things easier I provide a script that replaces the files inside the jar. Furthermore, it creates a backup of the original file.
Alternatively you can simply exchange the files manually.

### Option 1: Install (and backup) automatically

1. Stop IntelliJ IDEA
1. // TBD
1. Start IntelliJ IDEA

### Option 2: Install manually (jar console command)

1. Stop IntelliJ IDEA
1. Execute the following commands to replace the files inside the jar package. These commands are updating the specified files inside the jar container. Your local path must match the path inside the jar.
    ``` sh
    jar -ufv idea.jar com/intellij/ide/ui/laf/intellijlaf.properties
    jar -ufv idea.jar com/intellij/ide/ui/laf/darcula/darcula.properties
    ```
1. Start IntelliJ IDEA

### Option 2: Install manually (file archiver)

1. Stop IntelliJ IDEA
1. Locate the _idea.jar_ file on your system.
1. Open the idea.jar using a file archiver utility like 7zip.
1. Navigate to the following path inside the _idea.jar_ file:
    ``` sh
    com/intellij/ide/ui/laf/
    ```
1. Backup and then replace following files with the modified versions from this repository:
    ``` sh
    /intellijlaf.properties
    /darcula/darcula.properties
    ```
1. Start IntelliJ IDEA

## Known Issues

Until now I found no way to modify the following colours:

- _(Windows)_ The border colour of a focused button.
- _(Windows)_ The background colour of the left pane in the settings window.
- _(Windows)_ The background colour of the window title bar for the main windows as well as for any subwindow.
- _(Windows)_ Some drop-down elements in the setting are still grey (e.g. Settings > File Encodings).
- _(Windows)_ The "Search Everywhere" popup header is still blue.
- _(Windows)_ The radio buttons appearing in their default colour.
- _(Windows)_ The tab colours from the editor and some setting windows.

## Contributing

There are still many colours unchanged because I either found no changes as result of a modification or the behaviour of the setting was unstable or unpredicatable. As I can imagine the ffect of some properties are only visible in specific enviroments.
To make this IntelliJ theme more applicable to the solarized color scheme I need help to test it under more operating systems. Open an issue and tell me what was wrong or even better: Create a pull request with the appropriate changes.

Changing colours are more 'trial and error' then knowing what to do.
I tried to comment the changed elements as best as I can. Furthermore the source code of the community edition can show us some usages and hints for the unknown properties.

repository: devdev-dev/intellij-ui-colors-solarized

repo_name: devdev-dev/intellij-ui-colors-solarized


text:
---
category: minorAnalysis
---
* Fixed module resolution so we allow imports of definitions that have had an attribute assigned to it, such as `class Foo; Foo.bar = 42`.

repository: raulgarciamsft/ql

branch_name: refs/heads/main

gha_language: CodeQL

repo_name: raulgarciamsft/ql


text:
# design-patterns
Collection of design patterns(GoF).

## List of design patterns

### Behavioral patterns
1. Chain of responsibility
2. Command
3. Interpreter
4. Iterator
5. Mediator
6. Memento
7. Observer
8. State
9. Strategy
10. Template
11. Visitor

### Creational patterns
1. Abstract Factory
2. Builder
3. Factory Method
4. Prototype
5. Singleton

### Structural patterns
1. Adapter
2. Bridge
3. Composite
4. Decorator
5. Facade
6. Flyweight
7. Proxy

repository: rafaelkyrdan/design-patterns

repo_name: rafaelkyrdan/design-patterns


text:
#### [PATCH v5 00/10] arm64: Stolen time support
##### From: Steven Price<EMAIL_ADDRESS>
```c
From patchwork Wed Oct  2 14:50:27 2019
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
X-Patchwork-Submitter: Steven Price<EMAIL_ADDRESS>X-Patchwork-Id: 11171245
Return-Path<EMAIL_ADDRESS>Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org
 [<IP_ADDRESS>])
	by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 756E31747
	for<EMAIL_ADDRESS> Wed,  2 Oct 2019 14:50:56 +0000 (UTC)
Received: from vger.kernel.org (vger.kernel.org [<IP_ADDRESS>])
	by mail.kernel.org (Postfix) with ESMTP id 53FF121D7B
	for<EMAIL_ADDRESS> Wed,  2 Oct 2019 14:50:56 +0000 (UTC)
Received<EMAIL_ADDRESS>by vger.kernel.org via listexpand
        id S1728503AbfJBOux (ORCPT
        <rfc822;patchwork-kvm@patchwork.kernel.org>);
        Wed, 2 Oct 2019 10:50:53 -0400
Received: from foss.arm.com ([<IP_ADDRESS>]:46182 "EHLO foss.arm.com"
        rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP
        id S1726411AbfJBOuw (ORCPT <rfc822;kvm@vger.kernel.org>);
        Wed, 2 Oct 2019 10:50:52 -0400
Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [<IP_ADDRESS>])
        by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 02FCD28;
        Wed,  2 Oct 2019 07:50:52 -0700 (PDT)
Received: from e112269-lin.arm.com (e112269-lin.cambridge.arm.com
 [<IP_ADDRESS>])
        by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id
 F37553F706;
        Wed,  2 Oct 2019 07:50:49 -0700 (PDT)
From: Steven Price<EMAIL_ADDRESS>To: Marc Zyngier<EMAIL_ADDRESS>Will Deacon<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>Cc: Steven Price<EMAIL_ADDRESS> Catalin Marinas<EMAIL_ADDRESS> Paolo Bonzini<EMAIL_ADDRESS> =?utf-8?b?UmFkaW0gS3LEjW3DocWZ?=<EMAIL_ADDRESS> Russell King<EMAIL_ADDRESS>James Morse<EMAIL_ADDRESS> Julien Thierry<EMAIL_ADDRESS> Suzuki K Pouloze<EMAIL_ADDRESS> Mark Rutland<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>Subject: [PATCH v5 00/10] arm64: Stolen time support
Date: Wed,  2 Oct 2019 15:50:27 +0100
Message-Id<EMAIL_ADDRESS>X-Mailer: git-send-email 2.20.1
MIME-Version: 1.0
Sender<EMAIL_ADDRESS>Precedence: bulk
List-ID: <kvm.vger.kernel.org>
X-Mailing-List<EMAIL_ADDRESS>
This series add support for paravirtualized time for arm64 guests and
KVM hosts following the specification in Arm's document DEN 0057A:

https://developer.arm.com/docs/den0057/a

It implements support for stolen time, allowing the guest to
identify time when it is forcibly not executing.

Note that Live Physical Time (LPT) which was previously part of the
above specification has now been removed.

Also available as a git tree:
git://linux-arm.org/linux-sp.git stolen_time/v5

Changes from v4:
<EMAIL_ADDRESS> * Rebased to v5.4-rc1
 * Renamed KVM_ARM_VCPU_PVTIME_SET_IPA to remove _SET as it is used for
   both set/get operations
 * Added kvm/arm_hypercalls.h to header-test-$(CONFIG_ARM{,64}) as it is
   only buildable on arm/arm64
 * Documented no-steal-acc kernel parameter

Changes from v3:
<EMAIL_ADDRESS> * There's no longer a PV_TIME device, instead there are attributes on
   the VCPU. This allows the stolen time structures to be places
   arbitrarily by user space (subject to 64 byte alignment).
 * Split documentation between information on the hypercalls and the
   attributes on the VCPU
 * Fixed the type of SMCCC functions to return long not int

Changes from v2:
<EMAIL_ADDRESS> * Switched from using gfn_to_hva_cache to a new macro kvm_put_guest()
   that can provide the single-copy atomicity required (on arm64). This
   macro is added in patch 4.
 * Tidied up the locking for kvm_update_stolen_time().
   pagefault_disable() was unnecessary and the caller didn't need to
   take kvm->srcu as the function does it itself.
 * Removed struct kvm_arch_pvtime from the arm implementation, replaced
   instead with inline static functions which are empty for arm.
 * Fixed a few checkpatch --strict warnings.

Changes from v1:
<EMAIL_ADDRESS> * Host kernel no longer allocates the stolen time structure, instead it
   is allocated by user space. This means the save/restore functionality
   can be removed.
 * Refactored the code so arm has stub implementations and to avoid
   initcall
 * Rebased to pick up Documentation/{virt->virtual} change
 * Bunch of typo fixes

Christoffer Dall (1):
  KVM: arm/arm64: Factor out hypercall handling from PSCI code

Steven Price (9):
  KVM: arm64: Document PV-time interface
  KVM: arm64: Implement PV_FEATURES call
  KVM: Implement kvm_put_guest()
  KVM: arm64: Support stolen time reporting via shared structure
  KVM: Allow kvm_device_ops to be const
  KVM: arm64: Provide VCPU attributes for stolen time
  arm/arm64: Provide a wrapper for SMCCC 1.1 calls
  arm/arm64: Make use of the SMCCC 1.1 wrapper
  arm64: Retrieve stolen time as paravirtualized guest

 .../admin-guide/kernel-parameters.txt         |   6 +-
 Documentation/virt/kvm/arm/pvtime.txt         |  65 ++++++++
 Documentation/virt/kvm/devices/vcpu.txt       |  14 ++
 arch/arm/include/asm/kvm_host.h               |  26 +++
 arch/arm/kvm/Makefile                         |   2 +-
 arch/arm/kvm/handle_exit.c                    |   2 +-
 arch/arm/mm/proc-v7-bugs.c                    |  13 +-
 arch/arm64/include/asm/kvm_host.h             |  30 +++-
 arch/arm64/include/asm/paravirt.h             |   9 +-
 arch/arm64/include/asm/pvclock-abi.h          |  17 ++
 arch/arm64/include/uapi/asm/kvm.h             |   2 +
 arch/arm64/kernel/cpu_errata.c                |  80 ++++------
 arch/arm64/kernel/paravirt.c                  | 148 ++++++++++++++++++
 arch/arm64/kernel/time.c                      |   3 +
 arch/arm64/kvm/Kconfig                        |   1 +
 arch/arm64/kvm/Makefile                       |   2 +
 arch/arm64/kvm/guest.c                        |   9 ++
 arch/arm64/kvm/handle_exit.c                  |   4 +-
 include/Kbuild                                |   2 +
 include/kvm/arm_hypercalls.h                  |  43 +++++
 include/kvm/arm_psci.h                        |   2 +-
 include/linux/arm-smccc.h                     |  58 +++++++
 include/linux/cpuhotplug.h                    |   1 +
 include/linux/kvm_host.h                      |  26 ++-
 include/linux/kvm_types.h                     |   2 +
 include/uapi/linux/kvm.h                      |   2 +
 virt/kvm/arm/arm.c                            |  11 ++
 virt/kvm/arm/hypercalls.c                     |  68 ++++++++
 virt/kvm/arm/psci.c                           |  84 +---------
 virt/kvm/arm/pvtime.c                         | 124 +++++++++++++++
 virt/kvm/kvm_main.c                           |   6 +-
 31 files changed, 705 insertions(+), 157 deletions(-)
 create mode 100644 Documentation/virt/kvm/arm/pvtime.txt
 create mode 100644 arch/arm64/include/asm/pvclock-abi.h
 create mode 100644 include/kvm/arm_hypercalls.h
 create mode 100644 virt/kvm/arm/hypercalls.c
 create mode 100644 virt/kvm/arm/pvtime.c
```


text:
# ExtJS 4 Example using Ext.flash.ComponentView component #

This example shows how to add a flash file (.swf) inside an ExtJS 4 Component.

[Blog post - step by step](http://loianegroner.com/2012/07/tutorial-adding-a-flash-file-inside-an-extjs-4-component/)

Via [Loiane Groner](http://loianegroner.com).

repository: extjs/SenchaTry

repo_name: extjs/SenchaTry


text:
# Week_8_Eye_Project
MITxPro This project was a required component of the MITxPro Full Stack Developer Course

Description

This program utilizes HTML, CSS, and Javascript to create two eyes onscreen which then follow the User's mouse movements around the screen with its pupils.

How to Run

To run this program download the files and place in a folder together. Then drag and drop the index.html file to a browser. The eyes should appear and begin tracking the movements of the User's mouse immediately.

Roadmap of Future Improvements

1. In future I would like to create a button that randomizes the shapes and colors of the eyes.
2. Create a feature that adds more eyes to the screen in a grid.

Licensing

License information: The MIT License (X11 License) is a permissive free software license originating at the Massachusetts Institute of Technology (MIT) in the late 1980s. As a permissive license, it puts only very limited restriction on reuse and has, therefore, high license compatibility.

Copyright (c)

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

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

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


text:
# Book Trading Club
> Simple book trading webapp made as a project for the class Database Systems at Langara College.

## Installation

Set up the database:
```sh
mysql < ./database/tables.sql -u root -p [Type your server's password]
```

Install/update dependencies:
```sh
npm install
```

Run the webserver:
```sh
node app.js
```

Access the webpage:
```sh
localhost:3000
```

## Built With

* Node.JS
* Express.JS
* MySQL
* Bootstrap
* jQuery (AJAX Module)

## Authors

* **Caue Pinheiro** –<EMAIL_ADDRESS>* **Elian Figueiredo** –<EMAIL_ADDRESS>
## Meta

> Distributed under the MIT license. See ``LICENSE`` for more information.

repository: CaueStry/booktradingclub

repo_name: CaueStry/booktradingclub


text:
---
title: "Glossary of Terms"
linkTitle: "Glossary"
description: "Wondering about Sensu terminology? Read our glossary to learn the definition of common Sensu terms, including agent, asset, backend, check, event, and many more. Bonus: each term links to a corresponding guide!"
weight: 10
version: "5.6"
product: "Sensu Go"
menu:
  sensu-go-5.6:
    parent: getting-started
---

#### Agent
A lightweight client that runs on the infrastructure components you want to monitor.
Agents self-register with the backend, send keepalive messages, and execute monitoring checks.
Each agent belongs to one or more subscriptions that determine which checks the agent runs.
An agent can run checks on the entity it’s installed on or by connecting to a remote proxy entity.
[Read more.][1]

#### Asset
An asset is an executable that a check, handler, or mutator can specify as a dependency.
Assets must be a tar archive (optionally gzipped) with scripts or executables within a bin folder.
At runtime, the backend or agent installs required assets using the specified URL.
Assets let you manage runtime dependencies without using configuration management tools.
[Read more.][4]

#### Backend
A flexible, scalable monitoring event pipeline.
The backend processes event data using filters, mutators, and handlers.
It maintains configuration files, stores recent event data, and schedules monitoring checks.
You can interact with the backend using the API, command line, and dashboard interfaces.
[Read more.][2]

#### Check
A recurring check run by the agent to determine the state of a system component or collect metrics.
The backend is responsible for storing check definitions, scheduling checks, and processing event data.
Check definitions specify the command to be executed, an interval for execution, one or more subscriptions, and one or more handlers to process the resulting event data.
[Read more.][3]

#### Check hook
A command executed by the agent in response to a check result, before creating a monitoring event.
Hooks create context-rich events by gathering related information based on the check status.
[Read more.][5]

#### Check token
A placeholder used in a check definition that the agent replaces with local information before executing the check.
Tokens let you fine-tune check attributes (like thresholds) on a per-entity level while re-using the check definition.
[Read more.][16]

#### Entity
Infrastructure components that you want to monitor.
Each entity runs an agent that executes checks and creates events.
Events can be tied to the entity where the agent runs or a proxy entity that the agent checks remotely.
[Read more.][7]

#### Event
A representation of the state of an infrastructure component at a point in time, used by the backend to power the monitoring event pipeline.
Event data includes the result of the check or metric (or both), the executing agent, and a timestamp.
[Read more.][8]

#### Filter
Logical expressions that handlers evaluate before processing monitoring events.
Filters can instruct handlers to allow or deny matching events based on day, time, namespace, or any attribute in the event data.
[Read more.][9]

#### Handler
A component of the monitoring event pipeline that acts on events.
Handlers can send monitoring event data to an executable (or handler plugin), a TCP socket, or a UDP socket.
[Read more.][10]

#### Mutator
An executable run by the backend prior to the handler to transform event data.
[Read more.][11]

#### Plugin
Sensu Plugins are executables designed to work with Sensu event data, either as a check plugin, mutator plugin, or handler plugin.
You can write your own check executables in Go, Ruby, Python, and more, or use one of over 200 plugins shared by the Sensu Community.
[Read more.][6]

#### Proxy Entity
Components of your infrastructure that can’t run the agent locally (like a network switch or a website) but still need to be monitored.
Agents create events with information about the proxy entity in place of the local entity when running checks with a specified proxy entity id.
[Read more.][12]

#### RBAC
Role-based access control (RBAC) is Sensu’s local user management system.
RBAC lets you manage users and permissions with namespaces, users, roles, and role bindings.
[Read more.][13]

#### Resources
Objects within Sensu that can be used to specify access permissions in Sensu roles and cluster roles.
Resources can be specific to a namespace (like checks and handlers) or cluster-wide (like users and cluster roles).
[Read more.][18]

#### Sensuctl
Command line tool that lets you interact with the backend.
You can use sensuctl to create checks, view events, create users, manage cluster, and more.
[Read more.][14]

#### Silencing
Silences allow you to suppress execution of event handlers on an ad-hoc basis.
You can use silencing to schedule maintenances without being overloaded with alerts.
[Read more.][17]

[1]: ../../reference/agent/
[2]: ../../reference/backend/
[3]: ../../reference/checks
[4]: ../../reference/assets
[5]: ../../reference/hooks
[6]: ../../reference/checks
[7]: ../../reference/entities
[8]: ../../reference/events
[9]: ../../reference/filters
[10]: ../../reference/handlers
[11]: ../../reference/mutators
[12]: ../../reference/entities#proxy-entities
[13]: ../../reference/rbac
[14]: ../../sensuctl/reference/
[15]: ../../reference/checks/#subdue-attributes
[16]: ../../reference/tokens
[17]: ../../reference/silencing
[18]: ../../reference/rbac#resources

repository: sensu/sensu-docs

repo_name: sensu/sensu-docs


text:
React does not change much at how JS interact with the DOM. We can attach a submit handler specifying a `onSubmit` prop, this gets called when form gets submitted and will send an event with `target`.

To get the `value` of an element exists many ways:
* Via their index: `event.target.elements[0]`
* Via the elements object by their `name` or `id` attribute: `event.target.elements.usernameInput.value`

Once you get the value you can store it in a variable, pass to a function or do whathever you want. It's just a value 😉

In React the default event system of the browser is substitute from the SyntheticEvent, generally we do not need to access to the 'original' event system of our browsers but in any case if we need to do so we can do it by accessing the `nativeEvent` from the event object you're using.
```js
function CustomComponent(){
	// Can be fired by any event handled by React, onSubmit or onChange for example
	function eventHandler( event ){
		console.log(event); // returns an SyntheticEvent object
		console.log(event.nativeEvent); // returns a standard event
	}
}
```
## Using refs
React allows us to access to a DOM element, in this example allows us to access the `value` of an input by using a Ref. Use a ref require us to import a new Hook from React itself, the Hook is [[useRef]].
```js
import {useRef} from React
```
Once we have this Hook in our component we can store it in a variable and assign it's `current` value declaring the special prop `ref` right inside our component.
```js
function CustomComponent(){
	const myRef = useRef();

	function handleSubmit(){
			// Access the ref value once assigned via the first render of the component
		const InputValue = myRef.current.value; // It is extremely important to use current
	}

	return (
		<form onSubmit={handleSubmit}>
			<input ref={myRef} />
		</form>
	)

}
```
Using a ref is not always adviced and we will discover why in next workshop.
## Validating input via `useState`
When we change a ref we **do not cause a re-render** of our application, this means that we could fire some side-effects, for example checking an input, only if we force in some way a new render of our application (that obviously means that we should store somewhere the value we're working with).

In React we can re-render a component if it's state is changed, in order to manage a state we use the [[React.useState()|useState]] Hook that we can use straight from React or via importing.
```js
// Both are valid syntax

// In this case we first import useState and then use in our component
import {useState} from React;
function CustomComponent(){
	const [state, setState] = useState(0);
}

// Here we use straight the Hook without importing it first
function CustomComponent(){
	const [state, setState] = React.useState(0);
}
```
[[React.useState()|useState]] is an Hook that returns an array, we destructure those values with the knowledge that the first value we get is the current state and the second one is a special function that allow us to update the value in the state and fire the re-render of our application.

In this example having a state that holds the input value comes handy because allows us to check the value of the input at any moment and by re-rendering the component React allows us to show an error message id needed and also disable the submit button.

```js
function UsernameForm({onSubmitUsername}) {
	const [error, setError] = React.useState(null)

	function handleSubmit(event) {
	  event.preventDefault()
	  onSubmitUsername(event.target.elements.usernameInput.value)
	}

	function handleChange(event) {
	  const {value} = event.target
	  const isLowerCase = value === value.toLowerCase()
	  setError(isLowerCase ? null : 'Username must be lower case')
	}

	return (
	  <form onSubmit={handleSubmit}>
		<div>
		  <label htmlFor="usernameInput">Username:</label>
		  <input id="usernameInput" type="text" onChange={handleChange} />
		</div>
		<div role="alert" style={{color: 'red'}}>
		  {error}
		</div>
		<button disabled={Boolean(error)} type="submit">
		  Submit
		</button>
	  </form>
	)
}
```

repository: pra-exp/EpicReactNotes

path: /1. React Fundamentals/6. Forms.md

filename: 6. Forms.md

repo_name: pra-exp/EpicReactNotes


text:
---
layout:     post
title:      Paper Reading - A Joint Many-Task Model, Growing a Neural Network for Multiple NLP Tasks
date:       2019-07-03 00:00:00
summary:    It trains a 5 layers BiLSTM for 5 tasks, frow low-level to high-level.
categories: paper reading
---

## Problem

Perform multi-tasks in a hierarchical manner. Train a multi-layer model for multitasks. Different layers handle different tasks, from morphology, syntax to semantics.

## Key Ideas

1. Different layers handle different tasks.
2. Low-level layer handle easy task, high-level layer handle difficult task.
3. Tasks are stacked: POS - CHUNK - DEP - Relatedness - Entailment.
4. Train tasks sequentially, from easy to hard; add regularization term to prevent significant catastrophic forgetting.

## Model

![Joint Many-Task Model]({{"/images/2019-07-03-Joint-model.png"|prepend: site.baseurl}}){:width="350px"}

1. Structure

   - Each task utilizes one layer BiLSTM
   - n + 1 layer dependends on n-th layer output.

2. Data

   Use different existing labeled training data

3. Training

   Train tasks in sequence: POS, CHUNK, DEP, Relatedness, Entailment (from low-level to high level). Add successive regularization: make the previous layer output not change too much after training current layer.

## Performance

1. Joint model performs better than single task models.
2. Joint performance are comparable with existing single models.
3. Sequential training is better than shuffle.
4. Regularization is useful for tasks with small amount of data.

## Comments

1. Multi-task, task hierarchy are useful.
2. Train from bottom to top.
3. We can learn task dependency structure.
4. We can utilize better techniques for catastrophic forgetting. Besides, maybe sampling to improve tasks with limited data can help.

## Reference

Paper link: <https://aclweb.org/anthology/D17-1206>

url: https://raw.githubusercontent.com/BangLiu/BangLiu.github.io/b0d5822fd1d9ce6311811f704506dbc79e5c11aa/_posts/2019-07-03-A Joint Many-Task Model copy.md

gha_language: CSS


text:
Privacy Policy
===

GradleRIO collects some usage data during the build to help with future development. This data is anonymous, and is not available to the public. You may also opt out of this by disabling telemetry by adding the following to your build.gradle.
```gradle
telemetry {
    reportTelemetry = false
}
```
GradleRIO does not report telemetry when disabled as above, nor will it report if Gradle is run in an offline environment (e.g. with the `--offline` flag, or with no internet connection).

## What data?
You can see the exact data GradleRIO reports by running `./gradlew telemetry`.
GradleRIO reports the following data:
- `UUID`: A unique, randomly generated User ID.
- `OS`: Some information about the operating system (type, version, CPU architecture).
- `gradle`: Gradle version
- `plugins`: List of applied Gradle plugins (this helps us implement support for new languages like Kotlin, and new IDEs)
- `classpath`: List of Gradle plugin dependencies
- `deploy`: Some information on deployed targets
    - `targets`: Types of targets (e.g. RoboRIO). If a RoboRIO, also reports the team number (this helps avoid duplicate entries for multiple users on the same team)
    - `artifacts`: FRC-specific artifact types (this determines if GradleRIO uses the Java or C++ deploy logic)
- `dependencies`: List of project dependencies and their versions. This helps determine what versions of libraries are being used (e.g. wpilib/ctre/navx version), allowing extended support for other libraries.
- `wpi`: The configuration of the `wpi` block, including versions of wpilib, ntcore, opencv, shuffleboard, toolchain, etc.

## Distribution
Your user/team-specific usage data will not be made publically available. Period.

The only public uses for the data as a whole are:
- Demographic report (how many teams use GradleRIO, how many teams per country/state/region)
- OS Demographic report (what percentage of users use windows, mac, linux)
- Language Demographic report (how many teams use java/cpp/kotlin/others)
- Version Demographic report (how many teams use the kickoff release, how many use later/earlier releases)

Any public releases of the data will **NOT** show your team number, nor your unique user ID. Public defines any distribution at all.

Teams may ask what data we hold for them (build counts, unique users, etc) and we will be happy to forward them that information in the same forum from which it was asked, unedited. (Ammendment 1)

## How can I verify this?
The code that runs the telemetry is completely Open-Source. The Gradle side can be seen [here](https://github.com/Open-RIO/GradleRIO/tree/master/src/main/groovy/jaci/openrio/gradle/telemetry), and the server side can be seen [here](https://github.com/JacisNonsense/imjac.in_ta/blob/master/modules/openrio/openrio_library.rb).

repository: rrossbach/GradleRIO

repo_name: rrossbach/GradleRIO


text:
Mecode
======

[![Build Status](https://travis-ci.org/jminardi/mecode.svg?branch=master)](https://travis-ci.org/jminardi/mecode)

### GCode for all

Mecode is designed to simplify GCode generation. It is not a slicer, thus it
can not convert CAD models to 3D printer ready code. It simply provides a
convenient, human-readable layer just above GCode. If you often find
yourself manually writing your own GCode, then mecode is for you.

Basic Use
---------
To use, simply instantiate the `G` object and use its methods to trace your
desired tool path.

```python
from mecode import G
g = G()
g.move(10, 10)  # move 10mm in x and 10mm in y
g.arc(x=10, y=5, radius=20, direction='CCW')  # counterclockwise arc with a radius of 5
g.meander(5, 10, spacing=1)  # trace a rectangle meander with 1mm spacing between passes
g.abs_move(x=1, y=1)  # move the tool head to position (1, 1)
g.home()  # move the tool head to the origin (0, 0)
```

By default `mecode` simply prints the generated GCode to stdout. If instead you
want to generate a file, you can pass a filename and turn off the printing when
instantiating the `G` object.

```python
g = G(outfile='path/to/file.gcode', print_lines=False)
```

*NOTE:* `g.teardown()` must be called after all commands are executed if you
are writing to a file. This can be accomplished automatically by using G as
a context manager like so:

```python
with G(outfile='file.gcode') as g:
    g.move(10)
```

When the `with` block is exited, `g.teardown()` will be automatically called.

The resulting toolpath can be visualized in 3D using the `mayavi` package with
the `view()` method:

```python
g = G()
g.meander(10, 10, 1)
g.view()
```

Installation
------------
```bash
$ git clone https://github.com/jminardi/mecode.git
$ cd mecode
$ python setup.py install
```

Optional Dependencies
---------------------
The following dependencies are optional, and are only needed for
interpolation and visualization. An easy way to install them is to use
[Canopy][0] or [conda][1].

* numpy
    + numpy is needed for interpolation and visualization
* scipy
    + scipy is used for interpolation
* mayavi
    + mayavi is used for visualization

[0]: https://www.enthought.com/products/canopy/
[1]: https://store.continuum.io/cshop/anaconda/

TODO
----
* add pressure box comport to `__init__()` method
* build out multi-nozzle support
    * include multi-nozzle support in view method.
* factor out aerotech specific methods into their own class

Credits
-------
This software was developed by the [Lewis Lab][2] at Harvard University.

[2]: http://lewisgroup.seas.harvard.edu/

repository: alexvalentine/mecode

repo_name: alexvalentine/mecode


text:
---
layout: post
title: DB deployments with Fake.Sql.SqlPackage
date: 2019-12-23
excerpt_separator:  <!--more-->
tags: DB FAKE-tool
---

In my previous [post]({% post_url 2019-12-14-DB-deployments-with-FAKE-tool %}), I presented how we can deploy multiple visual studio database projects using [Fake build](https://fake.build/) tool. Here, I will present another option which is possible with version [5.19.0](https://github.com/fsharp/FAKE/releases/tag/5.19.0).

This version has a new module called [Fake.Sql.SqlPackage](https://fake.build/sql-sqlpackage.html), which is a redesign of previous [Fake.Sql.DacPac](https://fake.build/sql-dacpac.html) module. The reason, why the previous module needed redesign, it was a missing option (from my point of view crucial option) - publish profiles. I raised that point on GitHub [here](https://github.com/fsharp/FAKE/issues/2321) and solved it with this [pull request](https://github.com/fsharp/FAKE/pull/2366). If you are interested in SqlPackage itself you should check [the documentation](https://docs.microsoft.com/en-us/sql/tools/sqlpackage?view=sql-server-ver15).

To sum up this a bit long introduction - all that means that I had a pleasure to be Fake build contributor.

![Fake build feature release list](/images/fake_release_5.19.0.png)

### New publish target ###

All code can be found [here](https://github.com/kmadof/FsharpAdventCalendar2019) and is a continuation of the previous [post]({% post_url 2019-12-14-DB-deployments-with-FAKE-tool %}). The logic of DeployDb target doesn't change and thus I will skip it here. I will focus only on publish function which is used by this target.

Previously we used MSBuild tool to publish database projects.

{% highlight fsharp %}

let publish env (projectDirectoryPair:string * string) =
    let project, projectName = projectDirectoryPair
    MSBuild.runRelease  (fun p ->
        { p with Properties = [ ("DeployOnBuild", "true"); ("SqlPublishProfilePath","./Profiles/" + env + ".publish.xml") ] } ) (buildDir + projectName + "/") "Publish" (Seq.singleton project)
       |> Trace.logItems "DbDeploy-Output: "

{% endhighlight %}

In this approach, we build and publish the database. It means that we build project twice (once in BuildDb target and once in DeployDb target). With Fake.Sql.SqlPackage we can avoid that and use dacpac files created in BuildDb target as it is presented below.

{% highlight fsharp %}

let publishWithSqlPackageModule env (projectDirectoryPair:string * string) =
    let project, directory = projectDirectoryPair
    let dacPacPath = sprintf "./build/%s/%s.dacpac" directory directory
    let profile = sprintf "./%s/Profiles/%s.publish.xml" directory env

    Fake.Sql.SqlPackage.deployDb (fun args -> { args  with Source = dacPacPath; Profile = profile })

{% endhighlight %}

The function itself is simpler (in both version we just invoke Fake modules, but here we need to provide fewer parameters), but what is important even more. It is faster too. Publish with MSBuild takes 78 seconds.

![Deployments statistics with MS Build](/images/fake-deploy-target-ms-build.png)

While deployment with SqlPackage takes 66 seconds.

![Deployments statistics with SqlPackage](/images/fake-deploy-target-sql-package.png)

It may not seem like much, but SqlPackage version is 15.5% faster just on this example project. I made a similar switch in my company projects, which has a more complex database structure than this here. Numbers are much better - 172 seconds with MSBuild version versus 90 seconds with SqlPackage version. What gives 47.7% speedup! And it saves not only my time but everyone's time as we use it on our CI server.

### Summary ###

The conclusion will be really short. It is not the end of the world if open source software doesn't have needed feature. It can be your opportunity to pay back to the community.

gha_language: SCSS


text:
# Blurhash

> Make loading not so boring.

Install via [npm](https://www.npmjs.com/package/react-native-blurhash):

```sh
npm i react-native-blurhash
cd ios; pod install; cd ..
```

**BlurHash** is a compact representation of a placeholder for an image. This is a native UI module for React Native to wrap the Blurhash iOS and Android implementations and make them usable in React Native. See [woltapp/blurhash](https://github.com/woltapp/blurhash)

## Example Workflow

In order to use the Blurhash component, you have to already have a Blurhash string. See the [blurha.sh](https://blurha.sh) page to create example strings.

This is how I use it in my project:

1. A user uploads images from the react native app to firebase
2. In firebase, I have a storage trigger function that generates a blurhash string from the uploaded image using the [TypeScript implementation](https://github.com/woltapp/blurhash/blob/master/TypeScript/src/encode.ts)
3. After I generated the blurhash string, I set this as a property on my `post` document in Firestore.
4. Now everytime a user loads a feed of posts from my Firestore database, I use a `<Blurhash>` component (with the post's `blurhash` property) over my `<Image>` component, and fade it out once the `<Image>` component's [`onLoadEnd`](https://reactnative.dev/docs/image#onloadend) function has been called.

## Usage

The decoders are written in [Swift](ios/BlurhashDecode.swift) and [Kotlin](android/src/main/java/com/mrousavy/blurhash/BlurhashDecode.kt), and are copied from the official [woltapp/blurhash](https://github.com/woltapp/blurhash) repository. I use caching techniques, to only re-render the (quite expensive) Blurhash image creation when one of the blurhash specific props (`blurhash`, `decodeWidth`, `decodeHeight` or `decodePunch`) has changed.

    Name
    Type
    Explanation
    Required
    Default Value

    blurhash
    string
    The blurhash string to use. Example: LGFFaXYk^6#M<EMAIL_ADDRESS>    ✅
    undefined

    decodeWidth
    number
    The width (resolution) to decode to. This is not the same as the React Component's Style width! Higher values decrease performance, 32 is plenty!
    ❌
    32

    decodeHeight
    number
    The height (resolution) to decode to. This is not the same as the React Component's Style height! Higher values decrease performance, 32 is plenty!
    ❌
    32

    decodePunch
    number
    Adjusts the contrast of the output image. Tweak it if you want a different look for your placeholders.
    ❌
    1.0

    resizeMode
    'cover' | 'contain' | 'stretch' | 'center'
    Sets the resize mode of the image. See: Image:resizeMode
    ❌
    'contain'

    All View props
    ViewProps
    All properties from the React Native View. Use style.width and style.height for render-widths.
    ❌
    {}

> Read the [algorithm description](https://github.com/woltapp/blurhash/blob/master/Algorithm.md) for more details

Example Usage:

```tsx
import { Blurhash } from 'react-native-blurhash';

export default function App() {
  return (
    <Blurhash
      blurhash="LGFFaXYk^6#M<EMAIL_ADDRESS>      style={{flex: 1}}
    />
  );
}
```

### Example App

    iOS Screenshot
    Android Screenshot

To run the example App, execute the following commands:

```sh
cd react-native-blurhash/example/
yarn
cd ios; pod install; cd ..
npm run ios
npm run android
```

## Performance

The performance of the decoders is really fast, which means you should be able to use them in collections quite easily. Make sure to expect a small delay though, since it is still a complex decoding algorithm. By increasing the `decodeWidth` and `decodeHeight` props, the performance decreases. If you don't care much about the render resolution, use lower `decodeWidth` and `decodeHeight` values (`32` pixels wide is plenty!), and increase `style.width` and `style.height` values (or upscale it any other way like `flex`, `scale`, ...).

With both `decodeWidth` and `decodeHeight` set to `16` the image decoding takes about `2` milliseconds on iOS. For comparison, setting both `decodeWidth` and `decodeHeight` to `400` increases the decoding time to around `1.186` milliseconds.

At the moment, the Android decoder is faster than the iOS decoder, I'm not quite sure why.

## Resources
* [this medium article. jesus christ amen thanks for that](https://teabreak.e-spres-oh.com/swift-in-react-native-the-ultimate-guide-part-2-ui-components-907767123d9e)
* [Native Modules documentation, especially the Swift part](https://reactnative.dev/docs/native-modules-ios.html#exporting-swift)

repository: Lesliesibbs/react-native-blurhash

repo_name: Lesliesibbs/react-native-blurhash


text:
> [Go to French version](/fr/Règlements/Décrets,%20ordonnances%20et%20règlements%20statutaires/2004/308.md)

# Electronic Alternatives Regulations for the Purposes of the Federal Real Property and Federal Immovables Act

**SOR/2004-308**

Enabling authorities:
- [PERSONAL INFORMATION PROTECTION AND ELECTRONIC DOCUMENTS ACT](/en/Acts/Statutes%20of%20Canada/2000/c.%205.md)

Date registered: 13 December 2004

----------

The President of the Treasury Board, as the responsible authority for the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in accordance with the definition "responsible authority" in subsection 31(1) of the [Personal Information Protection and Electronic Documents Act](/en/Acts/Statutes%20of%20Canada/2000/c.%205.md)[a], pursuant to section 50 of that Act, hereby makes the annexed Electronic Alternatives Regulations for the Purposes of the Federal Real Property and Federal Immovables Act.

a: S.C. 2000, c. 5

Ottawa, December 6, 2004

Reginald B. Alcock

The President of the Treasury Board

## Interpretation

**1** The following definitions apply in these Regulations.

***Act*** means the [Personal Information Protection and Electronic Documents Act](/en/Acts/Statutes%20of%20Canada/2000/c.%205.md) unless the context otherwise requires. (*Loi*)

***Crown grant*** means any of the instruments or acts referred to in section 5 of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md), a plan referred to in section 7 of that Act or any other instrument or act by which federal real property may be granted. (*concession de l'État*)

***federal real property*** has the meaning assigned to that term in section 2 of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md). (*bien réel fédéral*)

***Ontario law*** means the applicable law of the Province of Ontario that requires or authorizes the use of electronic means in respect of documents to be registered. (*règles de droit de l'Ontario*)

***registered*** has the meaning assigned to that term in section 17 of the Land Registration Reform Act of Ontario. (*enregistré*)

## Application

**2** These Regulations apply only in respect of federal real property situated in the Province of Ontario.

## Electronic Documents

**3** For the purposes of the application of section 41 of the Act, an electronic document must be in the form required or authorized by the Ontario law in order for that electronic document to satisfy any requirement for a written document under
- **(a)** sections 5 and 7 of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of a Crown grant;
- **(b)** section 6 of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of a licence; and
- **(c)** section 11 of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of an instrument transferring administration and control.
> SOR/2005-408, s. 1.

## Electronic Signature

**4**

- **(1)** For the purposes of the application of section 43 of the Act, the electronic signature of a Minister must be in the form required or authorized by the Ontario law in order for that electronic signature to satisfy any requirement for signature or countersignature by that Minister
	- **(a)** under subsection 5(5) of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of any instrument or act referred to in paragraph 5(1)(b) or subsection 5(2) or (4) of that Act;
	- **(b)** under subsection 5(6) of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of any instrument or act referred to in paragraph 5(1)(b) or subsection 5(2) of that Act;
	- **(c)** under section 6 of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of a licence;
	- **(d)** under subsection 7(2) of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of a plan referred to in subsection 7(1) of that Act;
	- **(e)** under subsection 11(1) of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) in respect of an instrument transferring administration and control; and
	- **(f)** [Repealed, SOR/2005-408, s. 2]

- **(2)** For the purposes of the application of section 43 of the Act, the electronic signature of an officer authorized under section 3 of the [Federal Real Property and Federal Immovables Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2050.md) must be in the form required or authorized by Ontario law in order for that electronic signature to satisfy any requirement for signature or countersignature that is referred to in subsection (1).
> SOR/2005-408, s. 2.

## Coming into Force

**5** These Regulations come into force on the day on which they are registered.

repository: TravisMadill/CanadianLaws

path: /en/Regulations/Statutory Orders and Regulations/2004/308.md

repo_name: TravisMadill/CanadianLaws


text:
# IMDB-movie-list-details
A short Python script to fetch IMDB movie details, given the list url and number of movies to fetch.

## Tech used:
Python3 with BeautifulSoup

## Usage(command line exec):
arg1 -> url
arg2 -> count to fetch
```
python imdb_movies.py "https://www.imdb.com/india/top-rated-indian-movies" 5
```

repository: RaghuRajRai/IMDB-movie-list-details

repo_name: RaghuRajRai/IMDB-movie-list-details


text:
# serverless-nlp
Demo of a Serverless Natural Language Processing Service. This app uses:

- [spaCy](https://https://github.com/explosion/spaCy): deep learning NLP (natural language processing) library
- [Chalice](https://github.com/aws/chalice): serverless Python framework
- [AWS Lambda](https://aws.amazon.com/lambda/): FaaS compute service
- [API Gateway](https://aws.amazon.com/api-gateway/): API management service
- [Dashbird.io](https://dashbird.io/): monitoring, logging and anomaly detection

## Quick Demo

We've deployed a demo API for this application using [AWS Lambda](https://aws.amazon.com/lambda/) and [API Gateway](https://aws.amazon.com/api-gateway/).

You can try examples with a pre-determined text on these URLs:

- Sentence Extraction: [https://g5kl1e9fhf.execute-api.us-east-1.amazonaws.com/api/example/sentence](https://g5kl1e9fhf.execute-api.us-east-1.amazonaws.com/api/example/sentence)
- Named Entity Recognition: [https://g5kl1e9fhf.execute-api.us-east-1.amazonaws.com/api/example/named-entity](https://g5kl1e9fhf.execute-api.us-east-1.amazonaws.com/api/example/named-entity)
- Part-of-Speech Tagging: [https://g5kl1e9fhf.execute-api.us-east-1.amazonaws.com/api/example/part-of-speech](https://g5kl1e9fhf.execute-api.us-east-1.amazonaws.com/api/example/part-of-speech)

The text used for the examples above is:

> Lambda is an event-driven, serverless computing platform provided by Amazon as a part of the Amazon Web Services. It is a computing service that runs code in response to events and automatically manages the computing resources required by that code. It was introduced in November 2014. Andy Jassy is the CEO of Amazon Web Services. The company earned $17.4 billion in revenue and $4.331 billion in profits in the year of 2017. Source: Wikipedia.org.

To try the API with your own text sample, use cURL:

`curl -XPOST -H "Content-type: application/json" -d '{"data_type": "named-entity", "text": "Your text goes here!", "model_name": "en_core_web_sm"}' 'https://g5kl1e9fhf.execute-api.us-east-1.amazonaws.com/api/extract'`

In the `data_type` argument, you can provide:

- sentence
- named-entity
- part-of-speech

This demo API only supports text in English, having only one model deployed (en_core_web_sm). You can clone/fork this repo and deploy other [spaCy models](https://spacy.io/usage/models) to support multiple languages.

## Pre-requisites

- [Python 3.6+](https://www.python.org/downloads/release/python-370/)
- [pip 18.1+](https://pypi.org/project/pip/)

repository: tanjinadnanabir/serverless-nlp

repo_name: tanjinadnanabir/serverless-nlp


text:
---
id: 889
title: Install ZeroMQ plugin for MySQL
date: 2015-08-25T02:28:24+00:00
author: edyliu
layout: post
guid: http://<IP_ADDRESS>:8880/?p=883
permalink: /2015-08-install-zeromq-plugin-for-mysql/
categories:
  - Howto
tags:
  - mysql
---
Following steps in CentOS 6.x

Download cmake , use the binary one. such as: cmake-3.2.3-Linux-x86_64.sh

http://www.cmake.org/download/

Install Cmake

chmod +x cmake-3.2.3-Linux-x86_64.sh

./cmake-3.2.3-Linux-x86_64.sh

Get mysql zeromq plugin:

git clone https://github.com/netkiller/mysql-zmq-plugin.git

<!--more-->

Update headers:

cd mysql-zmq-plugin

vi CMakeLists.txt , replace with your own headers

”INCLUDE_DIRECTORIES(/usr/local/mysql-xxx/include)”

”INCLUDE_DIRECTORIES(/usr/local/zeromq-xxx/include)”

cmake .

make

Then you will get libzeromq.so

sudo cp libzeromq.so /path/to/mysql/plugin

Refer:

http://zeromq.org/event:zeromq-for-mysql

Known issue:

If you got following complain:

<pre>/usr/bin/ld: cannot find -lzmq
collect2: ld returned 1 exit status
make[2]: *** [libzeromq.so] Error 1
make[1]: *** [CMakeFiles/zeromq.dir/all] Error 2
</pre>

you can

ln -s your\_zmq\_so to /lib64/libzmq.so