text:
---
layout: post
title: "Compounding expectations in Rspec and Chai"
author: evanbrodie
date: 2016-10-05T17:17:39+00:00
---

When I had multiple expectations on the same object in **rspec**, I would write the code like so:

```ruby
expect(page).to have_content("Foo")
expect(page).to have_content("Bar")
expect(page).to have_content("Other Stuff")
```

You can save yourself some typing if you instead use [compound expectations](https://www.relishapp.com/rspec/rspec-expectations/v/3-5/docs/compound-expectations), which is basically the usage of the `and` function after the previous expectation. Doing so will allow the previous code to be writted as such:

```ruby
expect(page).to have_content("Foo")
  .and have_content("Bar")
  .and have_content("Other Stuff")
```

The same concept also exists in the **Chai** JavaScript testing library ([documentation](http://chaijs.com/api/bdd/)):

```javascript
expect(page).to.contain("Foo")
  .and.contain("Bar")
  .and.contain("Other Stuff");
```

repository: nulogy/til

gha_language: CSS

repo_name: nulogy/til


text:
### Necessary Environment

1. Java environment, the project is developed with java, java runtime environment is required, version: jdk8
2. MySQL database service, the project uses MySQL to store data, so MySQL is a must, version 5.7.x

### Non-essential environment

1. redis
2. elasticsearch

These two services are described in the following configuration

Just like these two, you can build a forum of your own, of course, this is only used in the LAN.
If you want to build the line, please see the configuration method below.

license: MIT

repository: entanmo/etmbbs

branch_name: refs/heads/master

extension: md

gha_language: Java

gha_license_id: MIT

license_type: permissive

repo_name: entanmo/etmbbs


text:
# Bonus!

"Why did you mention 3 tasks while there's 4?" you may ask.. read below!

## Goal

You set your own goal! If you feel previous tasks were simple and you're not satisfied, it is now your turn to come up with some CasperJS rainbowz!

Note: Please start this only if you have completed all previous tasks since they are supposed to teach you some basic CasperJS skills.

## Steps

1. Do something cool
2. Do more cool stuff
3. Improve, add rainbowz and unicornz!
4. Show the rainbowz to other people, celebrate!

## Tips

* Have fun
* Laugh a lot
* Invite others to create with you

## Key Learnings

* Magic skills

. * ･ ｡ﾟ☆━੧༼ •́ ヮ •̀ ༽୨

* CasperJS Super Powerz

/╲/\╭( •̀ ᗜ •́ )╮/\╱\

* Nerdiness boost

ᕙ(▀̿̿Ĺ̯̿̿▀̿ ̿) ᕗ

repository: maciejsmolinski/casperjs-training

repo_name: maciejsmolinski/casperjs-training


text:
<!-- Please provide a summary of the feature you would like implemented. -->
<!-- You may add or remove sections that aren't applicable at your own -->
<!-- discretion. -->

### Feature Request

**Feature Summary**

<!-- Place as much text as necessary here to describe the feature. Any -->
<!-- example code demonstrating how you would imagine this feature fitting -->
<!-- into VICE's API would be helpful, though aren't necessary. -->

```python
# Paste here any example code demonstrating how you as the user might
# interact with this feature after it's been implemented.
#
```

**Desired Output**

<!-- Place here any description of the output you would expect from this -->
<!-- feature, including any console output or more example code. -->

repository: giganano/VICE

branch_name: refs/heads/main

gha_language: Python

repo_name: giganano/VICE


text:
![](logo.png)

[![Coverage Status](https://coveralls.io/repos/github/go-chassis/go-chassis/badge.svg)](https://coveralls.io/github/go-chassis/go-chassis)
[![Go Report Card](https://goreportcard.com/badge/github.com/go-chassis/go-chassis)](https://goreportcard.com/report/github.com/go-chassis/go-chassis)
[![GoDoc](https://godoc.org/github.com/go-chassis/go-chassis?status.svg)](https://godoc.org/github.com/go-chassis/go-chassis)
[![HitCount](http://hits.dwyl.io/go-chassis/go-chassis.svg)](http://hits.dwyl.io/go-chassis/go-chassis)
[![goproxy.cn](https://goproxy.cn/stats/github.com/go-chassis/go-chassis/badges/download-count.svg)](https://goproxy.cn)
[![Documentation Status](https://readthedocs.org/projects/go-chassis/badge/?version=latest)](https://go-chassis.readthedocs.io/en/latest/?badge=latest)

[中文版README](README_cn.md)

Go-Chassis is a microservice framework for rapid development of microservices in Go.
it focus on helping developer to deliver cloud native application more easily.
The idea of logo is, developer can recreate and customize their own "wheel"(a framework) by go chassis to accelerate the delivery of software.

### Why use Go chassis
- powerful middleware "handler chain":
powerful than "filter" or "interceptor".
each handler in chain is able to get the running result of backward handler and your business logic.
It is very useful in varies of scenario, for example:
1. a circuit breaker need to check command results
2. track response status and record it, so that prometheus can collect them
3. track critical response result, so that you can audit them
4. distribute tracing, you can complete the end span spec after business logic executed

the commonplace above is helping you decouple common function from business logic. without handler chain.
those function will couple with business logic

- go chassis is designed as a protocol-independent framework, any protocol
is able to integrate with go chassis and leverage same function like load balancing,
circuit breaker,rate limiting, routing management, those function resilient your service

- go chassis makes service observable by bringing open tracing and prometheus to it.

- go chassis is flexible, many different modules can be replaced by other implementation,
like registry, metrics, handler chain, config server etc

- With many build-in function like route management, circuit breaker, load balancing, monitoring etc,
your don't need to investigate, implement and integrate many solutions yourself.

# Features
 - **Pluggable discovery service**: Support Service center, kubernetes.
 fit both client side discovery and server side discovery pattern,
 and you can disable service discovery to use end to end communication.
 - **Pluggable Protocol**:
 You can customize protocol, by default support http and grpc,
 go chassis define standardized [model](https://github.com/go-chassis/go-chassis/blob/master/core/invocation/invocation.go) to makes all request of different protocol leverage same features
 - **Multiple server management**: you can separate API by protocols and ports
 - **Handler Chain**: Able to add your own code during service calling for client and server side
 - **rich middleware**: based on handler chain,
 supply circuit breaker, rate limiting, monitoring, auth features.
 [see](https://go-chassis.readthedocs.io/en/latest/middleware.html)
 - **Traffic marker** Traffic marker module is able to mark requests in both client(consumer) or server(provider) side,
with marker, you can govern traffic based on it.
 - **Traffic management**: Able to route to different service based on weight and match rule, it can be used in many scenario, such as canary release
 - **Security**: build in cipher, authentication, RSA related funtions
 - **Safety and resilience**:
 support fault-tolerant(retry, rate limiting, client-side load-balancing, circuit breaker) to makes your service facing any unpredictable situation.
 - **Telemetry**: Able to expose Prometheus metric API automatically and customize metrics report.
 Use opentracing-go as standard library.
 - **Backing services**:
 use [backend service](https://go-chassis.readthedocs.io/en/latest/dev-guides/backends.html) as a plugin,
 so that your app can be easily tested, and swap to another plugin.
 - **Hot re-configuration**:
 Powered by go-archaius, configurations can be reload in runtime, like load balancing, circuit breaker,
 rate limiting, developer is also able to develop a service which has hot-reconfiguration feature easily.
 [see](https://go-chassis.readthedocs.io/en/latest/user-guides/dynamic-conf.html#)
 - **API first** go chassis will automatically generate Open API 2.0 doc and register it to service center. you can manage all the API docs in one place
 - **Spring Cloud** integrate with servicecomb, go chassis can work together with [spring cloud](https://github.com/huaweicloud/spring-cloud-huawei).
 - **Service mesh**: you can introduce multi-language to your microservice system. powered by [servicecomb-mesher](https://github.com/apache/servicecomb-mesher).
 - **Less dependencies**: checkout the go.mod file, it has less dependency on open source project by default, to import more features checkout [plugins](https://github.com/go-chassis/go-chassis-extension) to see more features

# Get started
1.Generate go mod
```bash
go mod init
```
2.Add go chassis
```shell script
 go get<EMAIL_ADDRESS>```
if you are facing network issue
```bash
export GOPROXY=https://goproxy.io
```

3.[Write your first http micro service](https://go-chassis.readthedocs.io/en/latest/getstarted/writing-rest.html)

# Documentations
You can see more documentations in [here](https://go-chassis.readthedocs.io/),

# Examples
You can check examples [here](examples)

NOTICE: Now examples is migrating to [here](https://github.com/go-chassis/go-chassis-examples)
# Communication Protocols
Go-Chassis supports 2 types of communication protocol.
1. http - an approach that leverages the HTTP protocol for communication.
3. gRPC - native grpc protocol, go chassis bring circuit breaker, route management etc to grpc.
## Debug suggestion for dlv:
Add `-tags debug` into go build arguments before debugging, if your go version is go1.10 onward.

example:

```shell
go build -tags debug -o server -gcflags "all=-N -l" server.go
```

Chassis customized `debug` tag to resolve dlv debug issue:

https://github.com/golang/go/issues/23733

https://github.com/derekparker/delve/issues/865

# Other project using go-chassis
- [apache/servicecomb-kie](https://github.com/apache/servicecomb-kie):
A cloud native distributed configuration management service, go chassis and mesher integrate with it,
so that user can manage service configurations by this service.
- [apache/servicecomb-mesher](https://github.com/apache/servicecomb-mesher):
A service mesh able to co-work with go chassis,
it is able to run as a [API gateway](https://mesher.readthedocs.io/en/latest/configurations/edge.html) also.
- [KubeEdge](https://github.com/kubeedge/kubeedge): Kubernetes Native Edge Computing Framework (project under CNCF) https://kubeedge.io

# Known Users
To register your self, go to https://github.com/go-chassis/go-chassis/issues/592

# Contributing
If you're interested in being a contributor and want to get involved in developing,
please check [CONTRIBUTING](CONTRIBUTING.md) and [wiki](https://github.com/go-chassis/go-chassis/wiki) for details.

[Join slack](https://go-chassis.slack.com/)
# Committer
- ichiro999
- humingcheng

repository: tianxiaoliang/go-chassis

repo_name: tianxiaoliang/go-chassis


text:
# Get LDAP Mail Users
[![Build Status](https://travis-ci.org/EndFirstCorp/getLdapMailUsers.svg?branch=master)](https://travis-ci.org/EndFirstCorp/getLdapMailUsers) [![Coverage Status](https://coveralls.io/repos/github/EndFirstCorp/getLdapMailUsers/badge.svg?branch=master)](https://coveralls.io/github/EndFirstCorp/getLdapMailUsers?branch=master)

A Dovecot and Postfix configuration writer to keep users synchronized between LDAP and Email servers

## Getting Started
    go get https://github.com/robarchibald/getLdapMailUsers

 1. Update ldapGetUsers.conf with the following information for your system installation
	- LdapServer - address of your OpenLDAP server
	- LdapPort - OpenLDAP server port
	- LdapBindDn - Admin bind username
	- LdapPassword - Password for Admin bind username
	- LdapBaseDn - root path for search
	- LdapQueryFilter - query filter for user search
	- DovecotPasswdPath - Dovecot passwd-style user file
	- PostfixVirtualMailboxAliasesPath - Postfix virtual mailbox alias file
	- PostfixVirtualMailboxDomainsPath - Postfix virtual mailbox domains file
	- PostfixVirtualMailboxRecipientsPath - Postfix virtual mailbox recipients path
	- PostmapPath - Path to postmap command (usually /usr/sbin/postmap)
 2. Run getLdapMailUsers executable. Dovecot passwd, Postfix virtual mailbox alias, Postfix virtual mailbox domains, and Postfix virtual mailbox recipients files will be created

repository: robarchibald/getLdapMailUsers

repo_name: robarchibald/getLdapMailUsers


text:
---
chapter: 12
title: Pappardelle
layout: post

---
Pappardelle is my favourite pasta but you could use any pasta you like for this.

Ideally you need a good pasta, garlic, salt, black pepper, flat leaf parsley, apple cider vinegar and olive oil.

Cook the pasta until al dente—important! If you over cook it here the texture will be all wrong so better to under cook it. Then run cold water through it until the pasta has cooled down completely and leave it covered with cold water.

Thinly slice garlic and add it to a large pan and gently fry it in olive oil. When it starts to sizzle add the drained pasta to it and gently mix the pasta with the garlic and olive oil. Add some apple cider vinegar and cover the pan with a lid and let the pasta warm up and cook a little. Careful not to cook too much—texture is everything. Half way through add some salt and black pepper and mix again. You need to make sure the pasta does not stick to the pan. Add more olive oil if necessary. For the last minute add some flat leaf parsley and combine it with the pasta.

Check that you’re happy with the seasoning—add more salt and black pepper if needed. Serve with some salad if you want.

This is my favourite way to eat pasta—forget all the sauces etc. I love the simplicity of this dish. You could add olives, some chilli flakes but that’s it. After that it becomes something else.

Use this as a basis to create other pasta dishes but for a very simple quick meal you cannot beat this. You can have this ready in under ten minutes.

repository: rajiv-shah/rajiv-sh

repo_name: rajiv-shah/rajiv-sh


text:
---
layout: post
title: Java Infos, Links
categories: [Dev, Code, Tools, Libs]
tags: [Java, Tools, Libs, Code, Concurrency]
---
![](../pics/20230707122349_java_hints.png)

# Java
# https://jenkov.com/
![](../pics/20230707122545_jenkov-tech.png)
## Java Concurrency

## Links

- <http://tutorials.jenkov.com/java-concurrency/index.html>
- <https://jenkov.com/>
-


text:
SportMonks API Client Library
=============================

[![Build Status](https://travis-ci.org/hristonev/sportmonks-client-bundle.svg?branch=master)](https://travis-ci.org/hristonev/sportmonks-client-bundle)

## API Version support

This API Client supports SportMonks v2.0.

## Requirements

- PHP 5.6 or higher

### Installation

`composer require hristonev/sportmonks-client-bundle`

## Configuration

``` php
// Bootstrap
require 'vendor/autoload.php';

use SportMonks\API\HTTPClient as SportMonksAPI;
use SportMonks\API\Utilities\Auth;

// Default values. Can be initialized without arguments.
$scheme = 'https';
$hostname = 'sportmonks.com';
$subDomain = 'soccer';
$port = 443;

// Auth.
$token = 'open sesame';

$client = new SportMonksAPI();
// or
//$client = new SportMonksAPI($scheme, $hostname, $subDomain, $port);

// Set auth.
$client->setAuth(Auth::BASIC, [
    'token' => $token
]);
```

## Usage example

### Paginated resource
``` php
$data = [];
do{
    $data = array_merge($data, $client->countries()->findAll());
}while($client->countries()->nextPage());
print_r($data);
```

## Reference

### Include data
``` php
$seasonId = 6361;
$teamId = 85;
$client->squad()->getBySeasonAndTeam(
    $seasonId,
    $teamId,
    [
        'query' => [
            'include' => 'player,position'
        ]
    ]
)
```
Above example, includes player info and player-position info into collection.
[Check](https://www.sportmonks.com/soccer/documentation/v2.0/items/includes-sortinglimiting/48) for more query parameters.

### Basic methods `endpoints`
Basic methods find({id}), findAll(), nextPage(). nextPage() is used on paginated response.

- continents
- countries
- leagues
- seasons
    - find(id, true) `Include results.`
    - standings(season_id)
    - standingsLive(season_id)
    - topScorers(season_id)
- fixtures
    - between()->period(from, to, teamId) `Params from and to are DateTime objects, teamId is integer. TeamId is optional.`
    - date()->day(date) `Param is DateTime object.`
    - commentaries(fixture_id)
    - videoHighlights(fixture_id)
    - tvStations(fixture_id)
    - odds(fixture_id)
    - oddsByBookmaker(fixture_id, bookmaker_id)
    - oddsByMarket(fixture_id, market_id)
    - oddsInPlay(fixture_id)
    - `Fixtures does not support findAll method.`
- teams
    - find(id, true) `Include stats.`
    - season(id) `Get teams by season.`
    - `Teams does not support findAll method.`
- head2Head
    - get(array) `Array must contain 2 elements(team1_id,team2_id).`
    - `There is no additional mthods.`
- liveScores
    - today()
    - inPlay()
- highlights
    - `Video haighlights does not support find method. Additional method in fixtures is presented.`
- venues
    - `Venue does not support findAll method.`
- bookmakers
- players
    - `Players does not support findAll method.`
- squad
    - getBySeasonAndTeam(season_id, team_id) `No other methods`

repository: hristonev/sportmonks-client-bundle

gha_language: PHP

repo_name: hristonev/sportmonks-client-bundle


text:
# Aioli Logging Formatter

Aioli logger (All In One LIne Logger) is a logging formatter for Rails 3.

Aioli make our meals delicious, right?

By default it logs lines of format:

    <date> <host> rails[<processId>] <sessionId> u<userId>: <message>

Examples:

    Nov 23 14:27:56 host rails[19572] f79a2d8633 u18: Completed in 1218ms (View: 772, DB: 209) | 200 OK [http://localhost/claims]
    Nov 23 14:27:56 host rails[19572] 0 u0: Completed in 1218ms (View: 772, DB: 209) | 200 OK [http://localhost/claims]

## Installation

Add this line to your application's Gemfile:

    gem 'aioli_log_formatter'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install aioli_log_formatter

## Usage

Enable the formatter:

    # config/application.rb
    ...
      class Application < Rails::Application
        ...
        config.aioli_log_formatter.enabled = true

Enable before filters to retrieve session ID and user ID from default sources.

    class ApplicationController < ActionController::Base

      aioli_log_formatter
      ...
    end

This is the same as:

    class ApplicationController < ActionController::Base

      aioli_log_formatter user_id: lambda { |controller| controller.session[:user_id] },
                       session_id: lambda { |controller| controller.request.session_options[:id] }
      ...
    end

To get the values from different sources simply change the procs, e.g.:

    class ApplicationController < ActionController::Base

      aioli_log_formatter user_id: lambda { |controller| controller.session[:account_id] }
      ...
    end

When using [Devise](https://github.com/plataformatec/devise) gem you can get the user ID as follows:

    class ApplicationController < ActionController::Base

      aioli_log_formatter user_id: lambda { |controller|
        user = controller.env['warden'].user
        user ? user.id : nil
      }
      ...
    end

## Define your own Formatter

Define your formatter by inheriting from `AioliLogFormatter::Formatter` for example:

    class MyAwesomeFormatter < AioliLogFormatter::Formatter

      # I like different formatting
      def call(severity, timestamp, progname, message)
        "#{timestamp} #{hostname} pid=#{process_id} sid=#{shorten_session_id} uid=#{user_id} msg=#{sanitize(message)}\n"
      end

    end

Have a look into source code of `AioliLogFormatter::Formatter` for more methods to overwrite.

Enable the formatter:

    # config/application.rb
    require_relative "../path/to/my_awesome_formatter"

    ...
      class Application < Rails::Application
        ...
        config.aioli_log_formatter.enabled = true
        config.aioli_log_formatter.formatter = MyAwesomeFormatter.new

See new formatting:

    2013-11-12 16:16:50 +0100 host pid=69402 sid=e36db0f022 uid=u42 msg=Started GET "/...

## Tests

Examples are located under `spec` and `test/dummy/spec` and are executed via:

    $ cd path/to/aioli_log_formatter
    $ bundle exec rake spec

## Credits

Inspired by [logjam_logger](https://github.com/alpinegizmo/logjam_logger)

## License

Copyright © 2013 [Thomas Baustert](http://thomasbaustert.de), released under the MIT license


text:
---
sidebar_position: 4
title: Creating a Kind cluster
description: Creating a local Kind-powered Kubernetes cluster.
keywords: [podman desktop, podman, containers, migrating, kubernetes, kind]
tags: [migrating-to-kubernetes, kind]
---

# Creating a local Kind-powered Kubernetes cluster

You can create multiple local Kind-powered Kubernetes clusters.

#### Prerequisites

- [You installed Kind](installing-kind).
- [On Windows, you configured Podman](configuring-podman-for-kind-on-windows).

#### Procedure

1. Go to **<icon icon="fa-solid fa-cog" size="lg" /> Settings > Resources**
1. In the Kind tile, click on the **Create new ...** button.
1. Choose your options, and click the **Create** button.

   The defaults are:

   - Name: `kind-cluster`
   - Provider type: `podman`
   - HTTP port: `9090`
   - HTTPS port: `9443`

1. (Optionally) Click the **Show logs** button to display the logs.
1. After successful creation, click on the **Go back to resources** button

#### Verification

1. In **<icon icon="fa-solid fa-cog" size="lg" /> Settings > Resources**, in the **Kind** tile, your `<kind-cluster>` instance is running.
1. In the Podman Desktop tray, open the **Kubernetes** menu, you can set the context to your Kind cluster: `kind-<kind-cluster>`.

repository: containers/podman-desktop

gha_language: TypeScript

repo_name: containers/podman-desktop


text:
Client
======

The Comms library is a high level abstraction of the ZeroMQ message passing protocol underlying the Edisense system.  It consists of two API classes and their associated handlers for the other end:
* `Client` - interactions with the cluster that might be done by a client
  * `put(node_t sender, transaction_t tid, std::list<std::string> &recipients,device_t deviceId, time_t timestamp, time_t expiration, blob data)`
    * Adds a blob of binary data to the cluster
  * `get(transaction_t tid, std::list<std::string> &recipients, device_t deviceId, time_t begin, time_t end)`
    * fetches the data from the provided range
  * `locate(device_t deviceId, std::string &recipient)`
    * returns the list of cluster members replicating data from the provided device
* `Member` - interactions with the cluster as performed by cluster members
  * `updatePartitionOwner(node_t sender,transaction_t tid,std::list<std::string> recipients,node_t newOwner,partition_t partition)`
    * Broadcasts an update to the cluster when partition ownership changes
  * `canReceiveRequest(node_t sender, transaction_t tid, std::string &recipient, partition_t partition_id)`
    * Asks a set of nodes on the cluster if they are capable of taking over ownership of a partition
  * `commitReceiveRequest(node_t sender, transaction_t tid, std::string &recipient, partition_t partition_id)`
    * Sets the node state to receiving if it is able to accept the partition
  * `commitAsStableRequest(node_t sender, transaction_t tid, std::string &recipient, partition_t partition_id)`
    * Marks the transaction state for partition ownership as stable

-----

Returned values are realized as futures to allow for non-blocking IO.  Members are also clients, and so can perform the same operations as a client would be able to.  Each class also contains a corresponding handler interface.  It is expected that the endpoint listening on the server side of the connection will implement the interface to fulfill requests.  Listening is begun when the server invokes `start(<HandlerType>)` on the object:

```cpp
int main(int argc, const char *argv[]) {
  edisense_comms::Member member;
  MyServer server;
  member.start(&server);  // Begins listening for member related events; dispatches them to MyServer object
  ...
}

class MyServer : public edisense_comms::MemberServer {
...
}
```

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

repository: Edisense/Comms

repo_name: Edisense/Comms


text:
# Ubuntu-18.04 - Compile Vulkan SDK for `ppc64el`

## Overview

This document describes how to compile the Vulkan SDK for `ppc64el` host architecture.

## Procedure

### Step 01.00: Install Vulkan SDK.

#### Step 01.01: Install required packages.

**Note:** While the procedure outlined below is generally correct, the current version of the
NVIDIA drivers (418.67) for `ppc64el` doesn't have support for Vulkan rendering. You will have
to wait for a newer driver (e.g. 430.40 or higher).

Download the vulkan sdk:
```bash
VULKAN_SDK_VERSION="<IP_ADDRESS>"
echo "downloading Vulkan SDK $VULKAN_SDK_VERSION" \
&& wget -q --show-progress --progress=bar:force:noscroll https://sdk.lunarg.com/sdk/download/$VULKAN_SDK_VERSION/linux/vulkansdk-linux-x86_64-$VULKAN_SDK_VERSION.tar.gz?Human=true -O /tmp/vulkansdk-linux-x86_64-$VULKAN_SDK_VERSION.tar.gz
```

Extract the vulkan sdk:
```bash
echo "extracting Vulkan SDK $VULKAN_SDK_VERSION" \
&& sudo mkdir -p /project/software/library/vulkan \
&& sudo chown -R administrator:administrator /project \
&& tar -xf /tmp/vulkansdk-linux-x86_64-$VULKAN_SDK_VERSION.tar.gz -C /project/software/library/vulkan \
&& rm /tmp/vulkansdk-linux-x86_64-$VULKAN_SDK_VERSION.tar.gz
```

#### Step 01.03: Modify Vulkan SDK sources for `ppc64el` dpkg architecture.

**Note:**
- `dpkg --print-architecture` returns `ppc64el`, the package architecture,
- `uname -m` returns `ppc64le`, whihc is the the actual cpu architecture.

The root SDK directory contains a script named vulkansdk to aid with building binaries. This script will build all the binaries included in the SDK, and also build those that are not included for compatibility reasons.

Modify the sources in the vulkan sdk to build for `ppc64el` dpkg arch:
```bash
nano /project/software/library/vulkan/<IP_ADDRESS>/vulkansdk
```

Make the following changes to the `vulkansdk` file, line 196 to query the host system architecture and set the `$ARCHDIR` output folder:
```bash
ARCH=`dpkg --print-architecture`
ARCHDIR="$SDKDIR/$ARCH"
```

#### Step 01.04: Update `~./bashrc` file.

Setup `~/.bashrc` for vulkan headers:
```bash
nano ~/.bashrc
```

```bash
# Set locate
export LC_ALL="en_US.UTF-8"
export LANG="en_US.UTF-8"

# shell
export PS1="${debian_chroot:+($debian_chroot)}\u:\W\$ "

# host
export DPKG_ARCH=`dpkg --print-architecture`

# Vulkan
VULKAN_SDK_VERSION="<IP_ADDRESS>"
export VULKAN_SDK="/project/software/library/vulkan/${VULKAN_SDK_VERSION}/$DPKG_ARCH"
export VK_LAYER_PATH="${VULKAN_SDK}/etc/explicit_layer.d"

export LD_LIBRARY_PATH="${VULKAN_SDK}/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}"
export PATH="${VULKAN_SDK}/bin${PATH:+:${PATH}}"
```

Source `~/.bashrc` to set environment variable before building the vulkan sdk:
```bash
source ~/.bashrc
```

#### Step 01.05: Build sdk tools.

Build the vulkan sdk tools:
```bash
cd /project/software/library/vulkan/${VULKAN_SDK_VERSION}

bash vulkansdk glslang loader layers tools lunarg-tools \
shaderc spirvtools spirvcross
```

#### Step 01.06: Build vulkan layer_factory.

**Note:** The vulkan layer_factory [sources](https://github.com/LunarG/VulkanTools/tree/master/layer_factory)
need to be patched to remove hard-coded entries for `x86_64` with `ppc64el` in the `sources/layer_factor/CMakeLists.txt` file:
```bash
sed -i 's/x86_64/ppc64el/g' "/project/software/library/vulkan/${VULKAN_SDK_VERSION}/source/layer_factory/CMakeLists.txt"
```

Build vulkan layer_factory:
```bash
bash vulkansdk vlf
```

#### Step 01.04: Build vulkan samples.

Note: The `VulkanSamples` [sources](https://github.com/LunarG/VulkanSamples)
need to be patched to remove hard-coded entries for `x86_64` with `ppc64el` in the `samples/CMakeLists.txt` file:
```bash
sed -i 's/x86_64/ppc64el/g' "/project/software/library/vulkan/${VULKAN_SDK_VERSION}/samples/CMakeLists.txt"
```
Build the vulkan sdk samples:
```bash
bash vulkansdk samples
```

After successfully running vulkansdk the files will be located under the "ppc64el" directory.

####  Step 01.04: Setup nvidia opengl and vulkan driver icds.

Ensure that the glvnd driver icd exists.

```bash
sudo nano /usr/share/glvnd/egl_vendor.d/10_nvidia.json
```

Ensure that the following entries exist:
```json
{
    "file_format_version" : "1.0.0",
    "ICD" : {
        "library_path" : "libEGL_nvidia.so.0"
    }
}
```

Create that the vulkan driver icd.

Create the file

```bash
sudo mkdir -p /usr/share/vulkan/icd.d
sudo nano /usr/share/vulkan/icd.d/nvidia_icd.json
```

Add the following entries:
```json
{
    "file_format_version" : "1.0.0",
    "ICD" : {
        "library_path": "libGLX_nvidia.so.0",
        "api_version" : "1.1.119"
    }
}
```

Check the nvidia-driver api version:
```bash
vulkaninfo | grep apiVersion

'DISPLAY' environment variable not set... skipping surface info
	apiVersion     = 0x401077  (1.1.119)
```

Check vulkan ray-tracing support:
```bash
vulkaninfo | grep VK_NV_ray_tracing
```


text:
# TaggedLogger
Detaches **what** is logged from **how** it is logged.

## What is it for?
Every time you want to log something, simply write:

    logger.debug("verbose debug information") #warn, #info, #error, #fatal also works

and do not worry about what kind of logger you use and how your code accesses it.
You may configure these things later, one day writing to STDOUT works for you, another
day you'll need something more sophisticated, like several log files each serving
different components and for different audience. [Here](http://afurmanov.com/2009/10/19/tagged-logger-introduction)
I have described in more details why I created it.

## Installation
    $ gem install tagged_logger

## Usage

After specifying some logging rules:

    TaggedLogger.rules do
      info A, :to => Logger.new("log_for_A_class.log") #1 rule
      error /.*/, :to => Logger.new(ERROR)             #2 rule
      info /.*/, :to => Logger.new(STDOUT)             #3 rule
    end

the following will happen:

1. The *#logger()* method becomes available **everywhere**, so it is completely safe to have a code like:

        class A
          def foo
             logger.info("Something interesting happened in A#foo") #goes to STDOUT and to 'log_for_A_class.log' file
             logger.debug("I want to see some details.") #goes nowhere
          end
        end
        logger.error("#logger is available everywhere") #goes to STDERR
        class B
           logger.warn("#logger is available everywhere") #goes to STDOUT
        end

2. The A's *logger.info()* output will show up in two destinations:

    - in STDOUT, as defined by rule #3

    - in 'log_for_A_class.log' file, as defined by rule #1

3. From **wherever** it gets called from:

        logger.error("ERROR") #will print 'ERROR' in standard error
        logger.info("INFO")  #will print 'INFO' in standard output
        logger.debug("DEBUG") #will not print anything, since there is no 'debug' rule

The *#logger()* returns some object having methods: *#debug(), #info(), #warn(), #error() and #fatal()*.
These methods have generated on first *#logger()* call and contain only necessary code to satisfy rules conditions.
It means, for example, that if no rules defined all these methods do **nothing**. It is done for performance
reasons, I like to log a lot and I do not want calls like *#logger.debug()* to slow down production code.

The simplest way to have a *#logger()* available everywhere without specifying any rules is:

    TaggedLogger.rules

No rules specified, therefore whenever you call *logger.debug()* (or alike) you actually paying for just an empty method
execution. You may specify rules later, now you may stay focused on code you are writing.

You may define your own formatting:

    TaggedLogger.rules do
      format {|level, tag, message| "#{level}-#{tag}: #{msg}"}
    end

Each *#format()* call overrides previous format.
If you are wondering what the heck the 'tag' is - the answer is simple. The tag is a class name
whose method calls *#logger()*. This is what allows to specify rules for classes or namespaces and this
is what the *tagged_logger* plugin is named after.

Lets see how you may use it. For example, you want to have separate log files
for classes *Network* and *Database*:

    TaggedLogger.rules do
      debug Network, :to => Logger.new("network.log")
      debug Database, :to => Logger.new("database.log")
    end

In case you want to define common log for several classes:

    TaggedLogger.rules do
      debug [Ftp, Http, Sockets], :to => Logger.new("network.log")
    end

Or if you want to have all these classes to show up under common
tag *Network* in standard output:

    TaggedLogger.rules do
      info /.*/, :to => Logger.new(STDOUT)
      rename [Ftp, Http, Sockets] => :Network
    end

You may also use regular expressions in your rules:

    TaggedLogger.rules do
      info /Active::/, :to => Logger.new("active.log")
    end

There is more general form for rules, it accepts block with three parameters:

    TaggedLogger.rules do
      info /Whatever/ do |level, tag, message|
        #do your special logging here
      end
    end

As previously explained the *tag* is a class name the *#logger* is being called from (except when you override Rails instrumentation, see below)

## Integration with Rails (only Rails 3.0 supported at the moment)

### Installation

    $ gem install tagged_logger

In Rails.root/config/application.rb:

       TaggedLogger.config(:replace_existing_logger => true)

Without that original methods *ActionController::Base#logger*, *ActiveRecord::Base#logger* and alike will remain untouched,
and they have to be patched if we want to redefine their behavior. By default *TaggedLogger* is safe and it
does not patch existing *#logger()* method.

### Logging in Rails

Rails has two facility for logging - *#logger* method injected in base classes (*ActiveRecord::Base*, *ActionController::Base*, etc.) and *instrumentation*.
Instrumentation in Rails allows to subscribe on event signaled upon block execution, for example:

    def sendfile(path, options={})
      ActiveSupport::Notifications.instrument("sendfile.action_controller") do
        #do actual file send
      end
    end

The event *"sendfile.action_controller"* will be signaled after actual work on sending file is done. One could subscribe to that event:

    ActiveSupport::Notifications.subscribe("sendfile.action_controller") do |*args|
      event = ActiveSupport::Notifications::Event.new(*args)
      #do something, for example, log an event
    end

### Overriding Rails logging
Logging inside Rails is done by log subscribers - their task to subscribe to instrumentation events, receive and log them.
*TaggedLogger* allows you to override how these subscribers work, for example,
you could redirect what is being logged in *ActionController* to some external hosted log service, like [Logbook.me](http://logbook.me/):

    # In Rails.root/config/initializers/tagged_logger.rb:
    TaggedLogger.rules do
      debug "action_controller.logsubscriber" do |level, tag, msg|
          Logbook.send(level, tag.to_s, :msg => msg.to_s )
      end
    end

You may also use *active_record.logsubscriber*, *action_mailer.logsubscriber*, *action_view.logsubscriber* and *rack.logsubscriber* tags.
If you'd like to have a special logging not only for *ActionController*, but rather for entire logging done in Rails (via instrumentation), you could use a
rule with regular expression:

    debug /\.logsubscriber$/ do |level, tag, msg|
      #your special logging
    end

Rails classes having method *#logger()* are patched by *tagged_logger* (only if it is configured
with option :replace_existing_logger => true, of cause), so you may define rules for your controllers and models,
for example:

    class ApplicationController < ActionController::Base
      def welcome
        logger.info "welcome..."
      end
    end

    # Rails.root/config/initializers/tagged_logger.rb
    TaggedLogger.rules do
      debug /.*Controller$/ do |level, tag, msg|
        puts "Here I dump whatever happens in controllers, including ApplicationController"
      end
    end

## License
*TaggedLogger* is released under the MIT license.

## Shortcomings
The *#info(), #debug(), #warn(), #error(), #fatal()* rules when having form like *:to => logger*, the
*logger* **has** to be an object of standard library *Logger* class.

extension: markdown


text:
## Contract Overview

The contract is split into three modules.

### 1. Club Contract
This contract maintains an array of address of different clubs
Each club address is mapped to a unique club name.

### 2. Player Contract :
This contract maintains a struct data type for every player that has been added
The attributes of the Player are ID, name, value, wage, year and the club address.

The player can belong to three states :
- TransferListed : The player has been added to the transfer list by a certain club.
- TransferAccept : A contract offered by another club for this player has been accepted by the current club.
- NotListed : The player has been bought by another club.

### 3. Transfer Contract

This contract handles the complexity wherein a player can be transferred from one club to another.
It maintains a contract structure (`struct Contract`) with attributes as follows:-

1. `contractID` - ID for each contract
2. `offerClub` - the offering club address
3. `offeredValue` - the value the offering club willing to offer.
4. `weeklyWage` - the weekly wage the offering club willing to offer.
5. `contractLength` - the length of the contract (usually in years)

- When a club creates a new player, A new ERC 721 token is created with the particular player ID and
is owned by the player's current club.
- `contractNo` maintains the number of contracts that each player has received
- Each Player ID is mapped to the player structure. On adding a new player, `contractNo[playerID]` is set to zero.
- In breif, each player ID is mapped to a contract ID which is mapped to the `Contract` structure [`mapping(uint => mapping(uint => Contract))`]
- Registered clubs can then buy a player by calling the `requestOffer`. Multiple clubs can send request offers for a particular player

The contract/offer can be accepted by the player's current club if the deal seems interesting
Once a contract has been accepted, state variables are modified accordingly and the token is transfer from the player's current club address to the buying club address, `transferFrom(_paddress, _caddress, _pid)`.

The buying club has to then Finalise the deal and transfer the new value of the player to player's old club.

### 4. Out of scope and Defects
- The contract doesnt allow a club to reject a particular offer.
- The contract transfers the token from one club to another before receiveing the funds (intend to fix this using Ethereum Alarm clock sevices).
- `weeklyWage` & `contractLength` are static variables that I intend to use them upon extending the feautres.
- Causes a lot of time delay between Accepting a contract and Finalising the Deal if the Dapp is not visited regularly.

### Contract Design and Flow
![Contract Design](https://github.com/sanjays95/player_transfer-Dapp/blob/master/contract_design.jpg?raw=true)


text:
Plan to cover several tools mentioned in the book with basic usage. Most content are based on [SupportingPython3](http://python3porting.com/pdfs/SupportingPython3-screen-1.0-latest.pdf).

```bash
$ virtualenv -p /usr/local/bin/python3.7 env
$ . env/bin/activate
```


text:
# World Newsletter Services List - XX

[![Language](<https://img.shields.io/badge/Language-XX-brightgreen.svg>)](https://github.com/roeniss/world-newsletter-services-list/blob/master/services/XX.md)

## 1.  No more available Services list

| Service Name | Short Description | Language | Homepage | Price |
| ------------ | ----------------- | -------- | -------- | ----- |
|              |                   |          |          |       |
|              |                   |          |          |       |
|              |                   |          |          |       |

repository: lipilman/world-newsletter-services-list

repo_name: lipilman/world-newsletter-services-list


text:
# Parsing
Parsing language files in an editor is configured in the `language` section of an ESV file. The syntax is as follows:

```esv
language

  table         : $Path
  start symbols : $Sorts

  line comment  : $String
  block comment : $String * $String
  fences        : $Fences
```

For example:

```esv
language

  table         : target/metaborg/sdf.tbl
  start symbols : File

  line comment  : "//"
  block comment : "/*" * "*/"
  fences        : [ ] ( ) { }
```

### Parse Table
The parse table of your language is set with the `table` key. By default, the parse table of an SDF specification is always produced at `target/metaborg/sdf.tbl`. It is only necessary to change this configuration when a custom parse table is used.

### Start Symbols
The `start symbols` key determine which start symbols to use when an editor is opened. This must be a subset of the start symbols defined in the SDF3 specification of your language.

Multiple start symbols can be set with a comma-separated list:

```esv
language

  start symbols : Start, Program
```

### Comments
The syntax for comments is:

```esv
language

  line comment  : $String
  block comment : $String * $String
```

For example, Java comments are specified as:

```esv
language

  line comment  : "//"
  block comment : "/*" * "*/"
```

The `line comment` key determines how single-line comments are created. It is used by editors to toggle the comment for a single line. For example, in Eclipse, pressing ++ctrl+slash++ (++cmd+slash++ on macOS), respectively comments or uncomments the line. The `block comment` key determines how multi-line comments are created. It is used when a whole block needs to be commented or uncommented. A block comment is described by the two strings denoting the start and end symbols of the block comment respectively.

### Fences
Fences for bracket matching are set as follows:

```esv
language

  fences : $Fences
```

The `fences` key determines which symbols to use and match for bracket matching. A single fence is defined by a starting and closing symbol. Multiple fences can be set with a space-separated list. Fences are used to do bracket matching in text editors.

For example, the default fences in a new Spoofax language project are:

```esv
language

  fences : [ ] ( ) { }
```

!!! warning "Multi-Character Fences"
    Fences can contain multiple characters, but some implementations may not handle bracket matching with multiple fence characters. For example, Eclipse does not handle this case and ignores multi-character fences.

gha_language: TeX


text:
---
repo: wq.db
date: 2013-09-18
---

# wq.db 0.3.0

### New Modules
- **[vera](https://github.com/powered-by-wq/vera)** (in `contrib`): An implementation of the [ERAV](https://andrewsheppard.net/research/provenance-volunteer-monitoring/) data model, which supports retaining provenance for observational data imported from spreadsheets

### API improvements
- Full read-write support for all four [design patterns](../wq.db/patterns.md): [annotate](../wq.db/patterns.md), [identify](../wq.db/patterns.md), [locate](../wq.db/patterns.md), and [relate](../wq.db/patterns.md).
- Integrated CRS-aware GeoJSON serialization.  Almost any page can now be rendered as GeoJSON simply by appending `.geojson` to the URL.  Pages with geometry will automatically have `'map': true` set in the [wq configuration object](../config.md) to enable use in [wq.app](../wq.app/index.md)'s [map.js](../@wq/map.md).
- Leveraging [Johnny Cache](https://pythonhosted.org/johnny-cache/) to cache both querysets and page rendering information for faster response times
- The set of valid `choices` for enum-style Django fields will be passed to the client via the [wq configuration object](../config.md)

### Other
- Various bug fixes & syntax improvements (e.g. PEP8)

repository: wq/wq

repo_name: wq/wq


text:
# LuaComponent

This is an ActorComponent allowing you to expose Actor's related data to the Lua Virtual Machine.

The Component itself will be mapped to a lua userdata on a specific LuaState with its virtual table (and metatable)

![LuaComponent](Screenshots/LuaComponent.PNG?raw=true "LuaComponent")

Create a new lua script with the following content:

```lua
actor = {}

function actor:get_hp()
    self.name = 'test'
    print(self)
    self.hp = self.hp + 1
    return self.hp
end
```

Note the colon-syntax for implementing OOP style programming. Basically the LuaComponent will automatically pass the userdata as the first argument of actor.get_hp:

![LuaComponent2](Screenshots/LuaComponent2.PNG?raw=true "LuaComponent2")

While the game runs, you can see the "Table" property being updated from lua:

![LuaComponent3](Screenshots/LuaComponent3.PNG?raw=true "LuaComponent3")

## Metatable

You can specify a metatable for the LuaComponent. As an example you may want to implement a "__tostring" function so when doing

```lua
print(self)
```

you can get a meaningful value:

![LuaComponent4](Screenshots/LuaComponent4.PNG?raw=true "LuaComponent4")

![LuaComponent5](Screenshots/LuaComponent5.PNG?raw=true "LuaComponent5")

## LuaComponent Interactions

When passing UObject's as LuaValue, they are incapsulated as userdata, so technically (by default) you cannot do anything relevant via Lua (except for passing them as arguments to functions). LuaComponents instead, get a proper metatable exposing the values set in the Table property. A Common pattern is to return the LuaComponent of an Actor to Lua, instead of the actor itself:

![PlayerToLuaComponent](Screenshots/PlayerToLuaComponent.PNG?raw=true "PlayerToLuaComponent")

Note that you can eventually assign an automatic metatable to UObjects too, using the LuaState UserData MetaTable features:
https://github.com/rdeioris/LuaMachine/blob/master/Tutorials/ReflectionShell.md

## Exposed Functions

### LuaCallFunction

```cpp
UFUNCTION(BlueprintCallable, meta = (AutoCreateRefTerm = "Args"))
FLuaValue LuaCallFunction(FString FunctionName, TArray<FLuaValue> Args, bool bGlobal);
```

Call a Lua function by its name. If bGlobal is false, the name will be searched in the component-associated virtual table.
The userdata is passed as the first argument.

### LuaCallValue

```cpp
UFUNCTION(BlueprintCallable, meta = (AutoCreateRefTerm = "Args"))
FLuaValue LuaCallValue(FLuaValue Value, TArray<FLuaValue> Args);
```

Takes a callable LuaValue and execute it passing userdata as the first argument.

### LuaGetField

```cpp
UFUNCTION(BlueprintCallable, BlueprintPure)
FLuaValue LuaGetField(FString Name);
```

Get a field value from the userdata virtual table

### LuaSetField

```cpp
UFUNCTION(BlueprintCallable)
void LuaSetField(FString Name, FLuaValue Value);
```

Set a field in the userdata virtual table

## Exposed Events

### OnLuaError

Triggered when the lua virtual machine generates an error when triggered from the LuaComponent. The error string is passed as the event argument

repository: rdeioris/LuaMachine

repo_name: rdeioris/LuaMachine


text:
[![npm version](https://badge.fury.io/js/ember-intercom-api.svg)](https://badge.fury.io/js/ember-intercom-api)
![ember-cli version](https://img.shields.io/badge/ember--cli-3.1.3-orange.svg)

# ember-intercom-api

This addon simply inject Intercom.io's script at runtime and gives you a nice interface for interaction with the script via `intercom` service.

## Installation

```bash
ember install ember-intercom-api
```

## Usage

You need to provide `appId` for Intercom's script:

```javascript
// config/environment.js

ENV['ember-intercom-api'] = {
  appId: '[YOUR_APP_ID]'
};
```

Please remember that you can make use of `environment` variable available in `config/enviroment`.
This way you can set testing `appId` for your `development` or `staging` environment:

```javascript
module.exports = function(environment) {
  var ENV = {
    //some stuff here
  };

  if (environment === 'staging' || environment === 'development') {
    ENV['ember-intercom-api'] = {
      appId: '[YOUR_TESTING_APP_ID]'
    };
  }
}
```

### Using API

Example:

```javascript
import { inject as service } from '@ember/service';
import Route from '@ember/routing/route';

export default Route.extend({
  intercom: service(),

  beforeModel() {
    this.get('intercom').boot();
  }
});
```

### Exposed API

These methods are exposed via `intercom` service and invoked on the Intercom script. Read [The Intercom JavaScript API](https://developers.intercom.com/docs/intercom-javascript) for more information.

- `.boot(intercomSettings)` - `intercomSettings` param is optional. If not given then `app_id` provided in `config/environment.js` will be used
- `.getVisitorId()`
- `.hide()`
- `.show()`
- `.showMessages()`
- `.showNewMessage(text)` - `text` param is optional
- `.shutdown()`
- `.trackEvent(eventName, params)`
- `.update(params)`

## Tests

You would rather like to avoid injecting Intercom's script to your Acceptance Tests and send the data.

This could be done by just not adding `ember-intercom-api` options to `ENV` variable:

```javascript
module.exports = function(environment) {
  var ENV = {
    //some stuff here
  };

  if (environment !== 'test') {
    ENV['ember-intercom-api'] = {
      appId: '[YOUR_APP_ID]'
    };
  }
}
```

or even better (as a more comprehensive example):

```javascript
module.exports = function(environment) {
  var ENV = {
    //some stuff here
  };

  switch(environment) {
    case 'production':
      ENV['ember-intercom-api'] = {
        appId: '[YOUR_APP_ID]'
      };
      break;

    case 'staging':
    case 'development':
      ENV['ember-intercom-api'] = {
        appId: '[YOUR_TESTING_APP_ID]'
      };
      break;
    default:
      break;
  }
}
```

### Linting

* `npm run lint:js`
* `npm run lint:js -- --fix`

### Running tests

* `ember test` – Runs the test suite on the current Ember version
* `ember test --server` – Runs the test suite in "watch mode"
* `ember try:each` – Runs the test suite against multiple Ember versions

### Running the dummy application

* `ember serve`
* Visit the dummy application at [http://localhost:4200](http://localhost:4200).

For more information on using ember-cli, visit [https://ember-cli.com/](https://ember-cli.com/).

License
------------------------------------------------------------------------------

This project is licensed under the [MIT License](LICENSE.md).

repository: brandnewio/ember-intercom-api

gha_language: JavaScript

repo_name: brandnewio/ember-intercom-api


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

### [1.0.1](https://github.com/5lava/terser-loader/compare/v1.0.0...v1.0.1) (2020-04-15)

### 1.0.0 (2020-04-03)

* Initial version

repository: vladnicula/terser-loader

repo_name: vladnicula/terser-loader


text:
# PerpsV2MarketDelayedExecution

## Description

**Source:** [contracts/PerpsV2MarketDelayedExecution.sol](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol)

## Constructor

### `constructor`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L29)

??? example "Details"

    **Signature**

    `constructor(address payable _proxy, address _marketState, address _owner, address _resolver)`

    **Visibility**

    `public`

    **State Mutability**

    ``

## Restricted Functions

### `cancelDelayedOrder`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L148)

??? example "Details"

    **Signature**

    `cancelDelayedOrder(address account)`

    **Visibility**

    `external`

    **State Mutability**

    ``

    **Requires**

    * [require(..., "no previous order")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L152)

    * [require(..., "use offchain method")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L154)

    **Modifiers**

    * [onlyProxy](#onlyproxy)

### `cancelOffchainDelayedOrder`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L169)

??? example "Details"

    **Signature**

    `cancelOffchainDelayedOrder(address account)`

    **Visibility**

    `external`

    **State Mutability**

    ``

    **Requires**

    * [require(..., "no previous order")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L173)

    * [require(..., "use onchain method")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L175)

    **Modifiers**

    * [onlyProxy](#onlyproxy)

### `executeDelayedOrder`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L56)

??? example "Details"

    **Signature**

    `executeDelayedOrder(address account)`

    **Visibility**

    `external`

    **State Mutability**

    ``

    **Requires**

    * [require(..., "no previous order")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L60)

    * [require(..., "use offchain method")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L62)

    * [require(..., "executability not reached")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L65)

    * [require(..., "order too old, use cancel")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L75)

    **Modifiers**

    * [onlyProxy](#onlyproxy)

### `executeOffchainDelayedOrder`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L105)

??? example "Details"

    **Signature**

    `executeOffchainDelayedOrder(address account, bytes[] priceUpdateData) payable`

    **Visibility**

    `external`

    **State Mutability**

    `payable`

    **Requires**

    * [require(..., "no previous order")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L109)

    * [require(..., "use onchain method")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L111)

    * [require(..., "price not updated")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L122)

    * [require(..., "executability not reached")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L123)

    * [require(..., "order too old, use cancel")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L124)

    **Modifiers**

    * [onlyProxy](#onlyproxy)

## Internal Functions

### `_cancelDelayedOrder`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L229)

??? example "Details"

    **Signature**

    `_cancelDelayedOrder(address account, struct IPerpsV2MarketBaseTypes.DelayedOrder order)`

    **Visibility**

    `internal`

    **State Mutability**

    ``

### `_confirmCanCancel`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L180)

??? example "Details"

    **Signature**

    `_confirmCanCancel(struct IPerpsV2MarketBaseTypes.DelayedOrder order, uint256 currentRoundId)`

    **Visibility**

    `internal`

    **State Mutability**

    ``

### `_confirmationWindowOver`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L198)

??? example "Details"

    **Signature**

    `_confirmationWindowOver(uint256 executableAtTime, uint256 currentRoundId, uint256 targetRoundId) view returns (bool)`

    **Visibility**

    `internal`

    **State Mutability**

    `view`

### `_executeDelayedOrder`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L273)

??? example "Details"

    **Signature**

    `_executeDelayedOrder(address account, struct IPerpsV2MarketBaseTypes.DelayedOrder order, uint256 currentPrice, uint256 currentRoundId, uint256 takerFee, uint256 makerFee)`

    **Visibility**

    `internal`

    **State Mutability**

    ``

### `_offchainAssetPriceRequireSystemChecks`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L213)

??? example "Details"

    **Signature**

    `_offchainAssetPriceRequireSystemChecks(uint256 maxAge) returns (uint256 price, uint256 publishTime)`

    **Visibility**

    `internal`

    **State Mutability**

    ``

    **Requires**

    * [require(..., "invalid, price is 0")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L218)

    * [require(..., "price divergence too high")](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L224)

### `_perpsV2ExchangeRate`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L36)

??? example "Details"

    **Signature**

    `_perpsV2ExchangeRate() view returns (contract IPerpsV2ExchangeRate)`

    **Visibility**

    `internal`

    **State Mutability**

    `view`

### `emitDelayedOrderRemoved`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L352)

??? example "Details"

    **Signature**

    `emitDelayedOrderRemoved(address account, uint256 currentRoundId, struct IPerpsV2MarketBaseTypes.DelayedOrder order)`

    **Visibility**

    `internal`

    **State Mutability**

    ``

## Events

### `DelayedOrderRemoved`

[Source](https://github.com/Synthetixio/synthetix/tree/v2.93.1/contracts/PerpsV2MarketDelayedExecution.sol#L339)

**Signature**: `DelayedOrderRemoved(address account, bool isOffchain, uint256 currentRoundId, int256 sizeDelta, uint256 targetRoundId, uint256 commitDeposit, uint256 keeperDeposit, bytes32 trackingCode)`

repository: Synthetixio/synthetix-docs

repo_name: Synthetixio/synthetix-docs


text:
# Change Log

All notable changes to this project will be documented in this file.

## Fine Beta-2

### Added
- Remove createfolder event handler since it is now handled by MiqVimBrokerWorker [(#100)](https://github.com/ManageIQ/manageiq-content/pull/100)
- Added LenovoXclarity Namespace to EMS Events into Automate [(#77)](https://github.com/ManageIQ/manageiq-content/pull/77)
- Automate - Notification for Ansible and Cloud provisioning errors. [(#15)](https://github.com/ManageIQ/manageiq-content/pull/15)
- Generic Service State Machine update_status change [(#85)](https://github.com/ManageIQ/manageiq-content/pull/85)
- Generic Service State Machine - new retirement instances. [(#72)](https://github.com/ManageIQ/manageiq-content/pull/72)
- Add Automate modeling for Embedded Ansible Events. [(#69)](https://github.com/ManageIQ/manageiq-content/pull/69)
- Add Automate modeling for External Ansible Tower Events. [(#68)](https://github.com/ManageIQ/manageiq-content/pull/68)
- Change default behavior of Service Retirement to not remove the Service [(#76)](https://github.com/ManageIQ/manageiq-content/pull/76)
- Generic Service State Machine - added notifications and improved logging. [(#61)](https://github.com/ManageIQ/manageiq-content/pull/61)
- Automate method to list ansible credentials [(#53)](https://github.com/ManageIQ/manageiq-content/pull/53)
- Add openstack cloud tenant events [(#59)](https://github.com/ManageIQ/manageiq-content/pull/59)

### Changed
- In the F release ConfigurationManagement has been deprecated [(#87)](https://github.com/ManageIQ/manageiq-content/pull/87)
- Refactoring and fixing cloud/vm/provisioning/placement/best_fit_amazon method. [(#63)](https://github.com/ManageIQ/manageiq-content/pull/63)
- Generic Service State Machine method update. [(#51)](https://github.com/ManageIQ/manageiq-content/pull/51)
- Generic Service State Machine methods modified to use Service object. [(#58)](https://github.com/ManageIQ/manageiq-content/pull/58)

### Fixed
- Add policy checking for the retirement request. [(#86)](https://github.com/ManageIQ/manageiq-content/pull/86)
- Modified vmware_best_fit_least_utilized to not select Hosts in maintenance. [(#81)](https://github.com/ManageIQ/manageiq-content/pull/81)
- Added method instances for EmbeddedAnsible [(#80)](https://github.com/ManageIQ/manageiq-content/pull/80)
- Fixes VM extend retirement [(#62)](https://github.com/ManageIQ/manageiq-content/pull/62)
- Disabled DeleteFromVMDB in 2 places [(#55)](https://github.com/ManageIQ/manageiq-content/pull/55)
- Fixed typo in check_ssh method [(#66)](https://github.com/ManageIQ/manageiq-content/pull/66)
- Generic State Machine provision instance fix [(#54)](https://github.com/ManageIQ/manageiq-content/pull/54)

repository: zeari/manageiq-content

repo_name: zeari/manageiq-content


text:
# Spike Plugin Directory

Spike's simple plugin directory

## Setup

- make sure [node.js](http://nodejs.org) is at version >= `6`
- `npm i spike -g`
- clone this repo down and `cd` into the folder
- run `npm install`
- run `spike watch` or `spike compile`

## License

Licensed under [MIT](license.md)

repository: static-dev/spike-plugin-directory

repo_name: static-dev/spike-plugin-directory


text:
# gulp-separate-media-queries

This project is used to generate a gulp plugin for extracting media queries from CSS.
Use case is to bundle media queries under a single css file

## Usage

```bash
npm install gulp-separate-media-queries
```

```javascript
// Initialize the plugin in your gulpfile
let extractQueries = require('gulp-separate-media-queries');

// For extracting all the media queries
stream = stream.pipe(extractQueries());

// For removing all the media queries use the removeQueries property
stream = stream.pipe(extractQueries({
  removeQueries: true
}));
```


text:
# PySpark ML Crashcourse

This repository contains exercises and solutions for a one-day crash course
for PySpark and Spark ML. The repository only contains Jupyter Notebooks which
assume a working PySpark kernel with Python 3.5 and Spark 2.1.

## Author

All notebooks have been create by Kaya Kupferschmidt @ dimajix. In case you
have any questions, feel free to contact me at<EMAIL_ADDRESS>

## 01 - PySpark DataFrame Introduction

This notebook contains some simple snippets to get a basic understanding how
to interact with Spark DataFrames in Python.

## 02 - PySpark Word Count (exercise + solution)

These notebooks contain the classic word count, implemented with DataFrames.

## 03 - Linear Regression (skeleton + solution)

These notebooks contain a simple linear regression exercise as an introduction
to machine learning with Spark.

## 04 - Text Classification (exercise + solution)

After being exposed to a simple linear regression, these notebooks contain an
exercise to perform a simple statistical text classification.

## 05 - Hyper Parameter Tuning (exercise + solution)

As with many complex algorithms and ML pipelines, the text classification has
many hyper parameters. These notebooks show how to perform hyper parameter
tuning with PySpark.

repository: kryvokhyzha/examples-and-courses

gha_language: Jupyter Notebook

repo_name: kryvokhyzha/examples-and-courses


text:
# Arduino MCP48xx Library

## Description
This is a small and simple library to control the MCP48xx family of digital to analog converters (DACs) with an Arduino board.

Currently it only works with the MCP4822, MCP4812, MCP4802 DAC.

## Installation

1. Navigate to the Releases page.
2. Download the latest release.
3. In the Arduino IDE, navigate to Sketch > Include Library > Add .ZIP Library and select the file downloaded.

You can find more information on installing Arduino libraries [here](https://www.arduino.cc/en/Guide/Libraries).

## Dependencies

This library depends on the standard [SPI](https://www.arduino.cc/en/Reference/SPI) library.

## Changelog

[Changelog](CHANGELOG.md)

## Licensing
The code in this project is licensed under MIT license.


text:
# Changelog

All notable changes to this project will be documented in this file.
Each new release typically also includes the latest modulesync defaults.
These should not affect the functionality of the module.

## [v0.1.1](https://github.com/voxpupuli/puppet-appd_db_agent/tree/v0.1.1) (2018-03-05)

[Full Changelog](https://github.com/voxpupuli/puppet-appd_db_agent/compare/v0.1.0...v0.1.1)

**Merged pull requests:**

- Add missing travis puppetforge deployment secret [\#6](https://github.com/voxpupuli/puppet-appd_db_agent/pull/6) ([alexjfisher](https://github.com/alexjfisher))

## [v0.1.0](https://github.com/voxpupuli/puppet-appd_db_agent/tree/v0.1.0) (2018-03-05)

[Full Changelog](https://github.com/voxpupuli/puppet-appd_db_agent/compare/38d9ce81db90939c7140a542d6e6d69d26233a17...v0.1.0)

**Merged pull requests:**

- Add extra validation for proxy\_port [\#4](https://github.com/voxpupuli/puppet-appd_db_agent/pull/4) ([alexjfisher](https://github.com/alexjfisher))
- Small doc updates [\#3](https://github.com/voxpupuli/puppet-appd_db_agent/pull/3) ([alexjfisher](https://github.com/alexjfisher))
- Add badges and fix up metadata.json for Vox Pupuli [\#2](https://github.com/voxpupuli/puppet-appd_db_agent/pull/2) ([alexjfisher](https://github.com/alexjfisher))

\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


text:
---
title: "SoftLayer_Virtual_Disk_Image_Software"
description: "A SoftLayer_Virtual_Disk_Image_Software record connects a computing instance's virtual disk images with software records... "
layout: "datatype"
tags:
    - "datatype"
    - "sldn"
    - "Virtual"
classes:
    - "SoftLayer_Virtual_Disk_Image_Software"
---

# SoftLayer_Virtual_Disk_Image_Software

 Datatype

## Description
A SoftLayer_Virtual_Disk_Image_Software record connects a computing instance's virtual disk images with software records. This can be useful if a disk image is directly associated with software such as operating systems.

### seeAlso

* [SoftLayer_Virtual_Disk_Image](/reference/services/SoftLayer_Virtual_Disk_Image )

* [SoftLayer_Software_Description](/reference/services/SoftLayer_Software_Description )

                <input placeholder="Datatype Filter" onkeyup="titleSearch(inputId='prop-input', divId='properties', elementClass='prop-row')"
                    type="text" id="prop-input" value="" size="30" maxlength="128" class="form-text">

## Local

-----
[id]: #id
#### [id]
The unique identifier of a virtual disk image to software relationship.
Type: **integer**

-----
[softwareDescriptionId]: #softwaredescriptionid
#### [softwareDescriptionId]
The unique identifier of the software that a virtual disk image is associated with.
Type: **integer**

## Relational

-----
[diskImage]: #diskimage
#### [diskImage]
The virtual disk image that is associated with software.
Type: **SoftLayer_Virtual_Disk_Image **

-----
[passwords]: #passwords
#### [passwords]
Username/Password pairs used for access to a Software Installation.
Type: **SoftLayer_Virtual_Disk_Image_Software_Password[] **

-----
[softwareDescription]: #softwaredescription
#### [softwareDescription]
The software associated with a virtual disk image.
Type: **SoftLayer_Software_Description **

## Count

-----
[passwordCount]: #passwordcount
#### [passwordCount]
A count of username/Password pairs used for access to a Software Installation.
Type: **unsigned long**

gha_language: HTML

gha_license_id: NOASSERTION


text:
---
layout: article
title: The Amazing Race Singapore
modified:
categories: scouting
excerpt: A race around the historical parts of Singapore with challenges along the way as part of the Expedition Challenge badge.
tags: [scouting, amazing_race, expedition_challenge_badge, challenge, race, activity, singapore]
image:
  feature:
  teaser:
  thumb:
comments: true
---

For the Expedition Challenge badge, the scouts in Singapore took part in an "Amazing Race" that we organised. This is of course not an officially sanctioned spin-off from the TV series, nor is there a single video camera to be seen. Leaders planned and organised the challenges at the different locations, and the role of the scouts was to first work out the different locations during their regular evening meetings, and plan their route between objectives.

Not all scouts were able to take part in the activity, so this post attempts to provide instructions so that those scouts that missed the event can still complete it and in doing so earn their badge.

{:.notice}
This post includes descriptions of the challenges and an explanation of how they should be completed. To avoid ruining the race for scouts taking part, **they should not read this blog post**, but should only be given the relevant pages from the "Challenge Pack" that can be downloaded at the end of this blog post.

## The Route And Waypoints

## Location A: Merlion

### Location A Challenges

## Location B: Chinatown

### Location B Challenges

## Location C: Kampong Glam

### Location C Challenges

## Location D: Little India

### Location D Challenges

## Downloadable Route and Challenge Pack


text:
# Tartiflette

# Table of Contents
* [About](#About)
* [Security Features](#Security-Features)

# About
Tartiflette is a library for building GraphQL APIs in Python, built with Python 3.6+

# Security Features
Tartiflette offers the following features:

```
| Field Suggestions | Query Depth Limit | Query Cost Analysis | Automatic Persisted Queries | Introspection      | Debug Mode | Batch Requests  |
|-------------------|-------------------|---------------------|-----------------------------|--------------------|------------|-----------------|
| No Support        | No Support        | No Support          | No Support                  | Enabled by Default | N/A        | No Support      |
```

Despite Tartiflette not having basic security support, it does provide [rate limits on a per field basis](https://tartiflette.io/docs/tutorial/rate-limit-fields-with-directives).


text:
## FIELD_FINAL_ASSIGNMENT ##

###Description###

This violation was raised because the field in the @Weave class is attempting to assign a value other than Weaver.callOriginal to a final field.

###Example###

####Original Class####
```
public class Example {

    private final String finalExample = "This is final";

}
```

####Bad####
```
@Weave
public class Example {

    private final String finalExample = "This doesn't work";

}
```

----------

####Good####
```
@Weave
public class Example {

    private final String finalExample = Weaver.callOriginal();

}
```

repository: newrelic/newrelic-java-agent

repo_name: newrelic/newrelic-java-agent


text:
Title: Reading Discussion 1: Environments, Virtual Machines and Containers
Category: readings
Date: 2020-01-07
Author: Pavlos Protopapas
Slug: reading1
Tags: Virtual Environments, Virtual Machines, Containers

## Selected Readings
#### Expository
- [Getting started with Python environments (using Conda)](https://towardsdatascience.com/getting-started-with-python-environments-using-conda-32e9f2779307)
- [Creating Python Virtual Environments with Conda: Why and How](https://heartbeat.fritz.ai/creating-python-virtual-environments-with-conda-why-and-how-180ebd02d1db)
- [Virtual Machine Wikipedia](https://en.wikipedia.org/wiki/Virtual_machine)
- [How to Install a Totally Free Windows 10 OS on Your Mac for Fun and Profit](https://towardsdatascience.com/how-to-install-a-free-windows-virtual-machine-on-your-mac-bf7cbc05888e)
- [Data Science for Startups: Containers](https://towardsdatascience.com/data-science-for-startups-containers-d1d785bfe5b)
- [Docker for Data Scientists](https://towardsdatascience.com/docker-for-data-scientists-5732501f0ba4)

#### Research
- [*Docker: Lightweight Linux Containers for Consistent Development and
Deployment*](https://www.seltzer.com/margo/teaching/CS508.19/papers/merkel14.pdf)
- [*Comparison of different Linux containers*](https://ieeexplore-ieee-org.ezp-prod1.hul.harvard.edu/abstract/document/8075934)
- [*Singularity: Scientific containers for mobility of compute*](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0177459)
- [*Performance Evaluation of Container-based Virtualization for High
Performance Computing Environments*](https://arxiv.org/pdf/1709.10140.pdf)

*Selected readings for presentation*


text:
# React Clean Architecture Example

Introducing Clean Architecture will make application sustainable and improve testability. We can receive the benefits of Clean Architecture not only for backend app but also for the frontend app.

This project introduces Clean Architecture in frontend and executes unit test using mock in each layer.

# How to run

Here's how to actually run this project.

## Mock Server

There is a flow to fetch some data in frontend, for that preparing a mock server to send temporary data.

```bash
$ cd mock_server
$ yarn
$ yarn start
```

## Frontend

```bash
$ yarn install
$ yarn start
```

Then open `http://localhost:1234` in your browser.

repository: t-tiger/React-CleanArchitecture-Example

repo_name: t-tiger/React-CleanArchitecture-Example


text:
# Structure-Preserving Graph Representation Learning

```
@inproceedings{spgrl_icdm22,
title = {Structure-Preserving Graph Representation Learning},
author = {Ruiyi Fang and Liangjian Wen and Zhao Kang and Jianzhuang Liu},
booktitle = {22nd {IEEE} International Conference on Data Mining (ICDM)},
pages = {927--932},
year = {2022}
}
```

links
- [ieee](https://doi.org/10.1109/ICDM54844.2022.00109)
- [arxiv](https://arxiv.org/abs/2209.00793)


text:
#  Molecule

## Why Molecule?

Molecule allows you to grab Twig components from outside the template folder. This is useful if you want to keep your Twig partials, CSS, React/Vue files, etc in a single component folder. Now all of your components are nicely organized in individual folder structures!

```
├── components/
│   ├── ButtonPrimary/
│   │   ├── index.css
│   │   ├── index.jsx
│   │   ├── index.twig
│   │   └── README.md
│   ├── Gallery/
│   ├── Hero/
│   └── VideoEmbed/
└── public/
    ├── cpresources/
    ├── index.php
    └── .htaccess
```

## Example use

Setup your `ButtonPrimary/index.twig` partial:
```twig
<a href="{{url}}"{% if newWindow is defined and newWindow %} target="_blank"{% endif %}>
  {{label}}
</a>
```

Then include in your Twig templates using the following syntax:
```twig
{{craft.molecule.get("ButtonPrimary", {
    url: "https://google.com",
    label: "Visit Google.com",
    newWindow: true
  })
}}
```

You can even include components in other components!

**/components/Hero/index.twig**
```twig
<div class="Hero">
  <img src="myImage.jpg" alt="A short description">

  {{craft.molecule.get("ButtonPrimary", {
      url: "#",
      label: "Learn more"
    })
  }}
</div>
```

## Icon Components
If you have an `Icon/` component there's an additional `craft.molecule.icon()` helper you can use to output the SVG directly into your templates.

```
├── components/
│   ├── Icon/
│   │   ├── images/
│   │   │    ├── arrow.svg
│   │   │    ├── play-button.svg
│   │   │    └── twitter.svg
│   │   ├── index.css
│   │   └── index.jsx
│   ├── Gallery/
└── public/
    ├── cpresources/
    ├── index.php
    └── .htaccess
```

```twig
{{craft.molecule.icon("twitter", { class: "custom_class" })}}
```

will compile to:

```html
<span class="Icon Icon--twitter custom_class">
  <!-- SVG contents of twitter.svg -->
</span>
```

## Testimonials
### Matt Rothenberg @mattrothenberg
> @aaronbushnell @CraftCMS I went all in 😜.
>
>Feels so nice to be able to "compose" components in a React-y way, too. https://twitter.com/mattrothenberg/status/1094693570177654784/photo/1
>
>

## Requirements

This plugin requires Craft CMS 3.0.0-beta.23 or later.

## Installation

To install the plugin, follow these instructions.

1. Open your terminal and go to your Craft project:

        cd /path/to/project

2. Then tell Composer to load the plugin:

        composer require trendyminds/molecule

3. In the Control Panel, go to Settings → Plugins and click the “Install” button for Molecule.

4. Configure the path to your components directory within Molecule's settings

## Credits
Icon by [Aaron Humphreys](https://dribbble.com/AarhCreative) — [Dribbble post](https://dribbble.com/shots/3506937-Free-iOS-App-Icons)

repository: bryantAXS/molecule

repo_name: bryantAXS/molecule


text:
# 101-jmh

A simple example to review JMH

## How to build?

```
mvn clean test
mvn versions:display-dependency-updates
mvn versions:display-plugin-updates
```

## Concepts

```
@BenchmarkMode(Mode.AverageTime)
http://javadox.com/org.openjdk.jmh/jmh-core/1.12/org/openjdk/jmh/annotations/Mode.html

All
Meta-mode: all the benchmark modes.

AverageTime
Average time: average time per per operation.

SampleTime
Sample time: samples the time for each operation.

SingleShotTime
Single shot time: measures the time for a single operation.

Throughput
Throughput: operations per unit of time.

@OutputTimeUnit(TimeUnit.MILLISECONDS)
OutputTimeUnit provides the default time unit to report the results in.

@State(Scope.Benchmark)

Benchmark
Benchmark state scope.
Group
Group state scope.
Thread
Thread state scope.

@Fork(value = 2, jvmArgs = {"-Xms2G", "-Xmx2G"})
Fork annotation allows to set the default forking parameters for the benchmark.

@Warmup(iterations = 3)
Warmup annotation allows to set the default warmup parameters for the benchmark.

@Measurement
Measurement annotations allows to set the default measurement parameters for the benchmark.

```

- https://jmh.morethan.io/
- https://nilskp.github.io/jmh-charts/
- https://github.com/akarnokd/jmh-compare-gui

## References

- https://openjdk.java.net/projects/code-tools/jmh/
- https://www.baeldung.com/java-microbenchmark-harness


text:
---
title: 7 SEO Black Hat practices to Avoid
date: "2018-04-20T23:46:37.121Z"
template: "post"
draft: false
slug: "seo-black-hat-practices"
category: "SEO"
tags:
  - "Web Development"
  - "SEO"
description: "SEO is an important and effective task that helps find content, index it and show relevant data online. While working on search engine optimization, you should never engage in shady practices to mislead search engines."
socialImage: "/media/image-2.jpg"
---

SEO is an important and effective task that helps find content, index it and show relevant data online. While working on search engine optimization, you should never engage in shady practices to mislead search engines. Dishonest and shady practices to get visibility for your website is referred to as “Black Hat” SEO. Here are some techniques you should be avoiding:

**Keyword Stuffing** -
Stuffing is overusing keywords in your content, in alt tags, in meta tags, in title tags, etc. Repeating words too often unnecessarily is not good. Search engines are smart enough to understand this and may apply filters to reduce your site ranking or may even ban your site. Examples of keyword stuffing: “Join us to learn best of yoga on yoga international day at therapy yoga centre as yoga is important for health and you can be fit by doing yoga.”, “yoga mat, yoga pants, yoga, yoga day, yoga, yoga”.

**Invisible Text** -
This is done by making text size too small or making the text color same as that of background color. That way visitors to the site cannot read the text but can be seen by search engine spiders. Search engines can figure out these tactics easily today, so it’s better to avoid such practice.

**Linking to poor quality websites** -
Linking your website to bad sites with unrelated content and which use stuffing techniques to increase their ranking is a bad idea. Always verify sites before linking. See that they are indexed by google and have good ranking and are not involved in any shady practice.

**Doorway Pages** -
Doorway pages or Gateway pages or call it orphaned pages are specially made with the purpose of getting high rank for a particular search. Such pages have particular targeted keywords and are often not part of a website. Often visitors land up on some unrelated page.

**Cloaking** -
Cloaking displays a page with different content to site visitors and a page with different content to search engines. For sole purpose of getting high ranking, cloaked page is stuffed with keywords. Your site can be penalised for manoeuvring rankings.

**Duplicate Content** -
Duplicating content means copying and pasting content from different sources to your site. Search engines look for unique content, so this is the worst black hat practice. Search engines cannot figure out who made the original content, so make sure no other site is duplicating your content. You can check that no one is duplicating your content by performing a search using some of your text with quotation marks (") around it.

**Link Farms** -
Link Farms are cluster of sites interlinked to each other with or without any relation with the purpose to get link popularity and increase Google page rank.

Black hat practices are very risky and can be caught by Search engines nowadays. If caught, your website can be fined and will lead to lower page ranking or even get banned. Avoid such malicious practices!


text:
### Description

### Fixes

<!-- list out issue numbers e.g. #102, #2 -->
<!-- feel free to remove or leave blank if this doesn't apply -->

### Breaking changes

<!-- feel free to remove or leave blank if this doesn't apply -->

### Checklist

- [ ] I have covered any new additions with tests
- [ ] I followed the [AngularJS Git Commit Message Conventions](https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit)
- [ ] I have [rebased unnecessary commits and rebased upstream changes from the parent branch](https://www.atlassian.com/git/tutorials/merging-vs-rebasing#workflow-walkthrough)

repository: suitejs/suitejs

repo_name: suitejs/suitejs


text:
---
site: freiburg
tags: [paper]
title: "The Transcription Factor ETV1 Induces Atrial Remodeling and Arrhythmia."
---

Carolin Rommel, from the Institute of Experimental and Clinical Pharmacology and Toxicology, recently published her
manuscript about ["The Transcription Factor ETV1 Induces Atrial Remodeling and Arrhythmia"](http://circres.ahajournals.org/content/early/2018/06/19/CIRCRESAHA.118.313036).
Great work, congratulations Carolin!

## Abstract

__Rationale__: Structural and electrophysiological remodeling of the atria are recognized consequences
of sustained atrial arrhythmias, such as atrial fibrillation (AF). The identification of underlying
key molecules and signaling pathways has been challenging due to the changing cell type composition
during structural remodeling of the atria. __Objective__: Thus, the aims of our study were (1) to search
for transcription factors and downstream target genes, which are involved in atrial structural remodeling,
(2) to characterize the significance of the transcription factor ETV1 in atrial remodeling and arrhythmia and
(3) to identify ETV1-dependent gene regulatory networks in atrial cardiac myocytes. __Methods and Results__:
The transcription factor ETV1 was significantly upregulated in atrial tissue from patients with permanent AF.
Mice with cardiac myocyte-specific overexpression of ETV1 under control of the myosin heavy chain promoter
developed atrial dilatation, fibrosis, thrombosis and arrhythmia. Cardiac myocyte-specific ablation of ETV1
in mice did not alter cardiac structure and function at baseline. Treatment with Ang II for two weeks
elicited atrial remodeling and fibrosis in control, but not in ETV1-deficient mice. To identify
ETV1-regulated genes, cardiac myocytes were isolated and purified from mouse atrial tissue.
Active cis-regulatory elements in mouse atrial cardiac myocytes were identified by chromatin
accessibility (ATAC-seq) and the active chromatin modification H3K27ac (ChIP-seq). 178 genes
regulated by Ang II in an ETV1-dependent manner were associated with active cis-regulatory
elements containing ETV1 binding sites. Various genes involved in Ca2+ handling or gap junction
formation (Ryr2, Jph2, Gja5), potassium channels (Kcnh2, Kcnk3) as well as genes implicated in
AF (Tbx5) were part of this ETV1-driven gene regulatory network. The atrial ETV1-dependent
transcriptome in mice showed a significant overlap with the human atrial proteome of patients
with permanent AF. __Conclusions__: This study
dentifies ETV1 as an important component in the pathophysiology of atrial remodeling
associated with atrial arrhythmias.

repository: subinamehta/website

repo_name: subinamehta/website


text:
Haskell
=======

This is the Haskell implementation of Pure. If you have [GHC][1], running `ghc --make pure` should build an executable called `pure`, which evaluates a Pure program from standard input and writes the result to standard output. You can alse do variable elimination (described in more detail in the Go `README`) by listing the variables on the command line:

	% ./pure nfx
	`f``nfx
	`s``s`ksk

[1]: http://www.haskell.org/ghc/

repository: anschelsc/pure

repo_name: anschelsc/pure


text:
# DelaunayTessellationFieldEstimator.jl

### What is it?

This package is an implementation the DTFE algorithm [(Schaap, 2007 PhD)](https://www.rug.nl/research/portal/files/2816076/c2.pdf)
for calculating an estimate of a particle density field (can be used for other fields too if the 'mass' is some another physical
attribute).

### Dependent on

- [GeometriclPredicates.jl](https://github.com/JuliaGeometry/GeometricalPredicates.jl)
- [VoronoiDelaunay.jl](https://github.com/JuliaGeometry/VoronoiDelaunay.jl)

### Current limitations

- Currently 2D since [VoronoiDelaunay.jl](https://github.com/JuliaGeometry/VoronoiDelaunay.jl) is and everything
  is based on this.

- 'Due to numerical restrictions the point coordinates must be within min_coord <= x <= max_coord where min_coord=1.0+eps(Float64) and max_coord=2.0-2eps(Float64). Note this is a bit different than what is required by the GeometricalPredicates package.' - Quote
[VoronoiDelaunay.jl](https://github.com/JuliaGeometry/VoronoiDelaunay.jl)

### TODO

- Nice and easy plotting + movie making :)
- 3D, would need [VoronoiDelaunay.jl](https://github.com/JuliaGeometry/VoronoiDelaunay.jl) updated.

### Example of what this does

#### A visualisation for a density field approximation

[Notebook](https://github.com/harveydevereux/DelaunayTessellationFieldEstimator.jl/blob/master/resources/Example.ipynb.tar.gz)
![density](https://github.com/harveydevereux/MSc-Project/blob/master/Resources/density.gif)


text:
# unity-cookbook-2018-ch02

## Chapter 2: Responding to User Events for Interactive UIs

Assets for the recipes

The **completed** Unity projects for each example can be found in their own repos as follows:

1. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-01-buttonsToMoveBetweenScenes

2. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-02-buttonAnimation

3. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-03-panelDepths

4. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-04-sliderValue

5. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-05-timerAsSlider

6. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-06-customMouseCursor

7. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-07-uiControlCursor

8. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-08-textInputEvents

9. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-09-toggleControl

10. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-10-dropdown

11. https://github.com/dr-matt-smith/unity-cookbook-2018-ch02-11-radar


text:
# Golden Sun Engine - HTML5
An online **Golden Sun Engine** entirely built in HTML5 with [PhaserJS CE 2.15.0](http://phaser.io/).

**See the [DEMO](https://jjppof.github.io/goldensun_html5/index).** Prefer to use Chrome based browsers.

- **This repository is just the engine**. I'm not planning to do maps, animations, items etc. Content here is just enough to show the functionalities.
- People should be able to make a GS like game without any programming skills with this project.
- Feel free to help! Check what I need help [here](https://github.com/jjppof/goldensun_html5/projects). Please, reach me if you want to do so.
- The goal of this project is not to do exactly the same engine as GS, but very similar.
- If you found any bug, please create an [issue](https://github.com/jjppof/goldensun_html5/issues/new) for it.
- Check the [wiki](https://github.com/jjppof/goldensun_html5/wiki) for database configuration, tutorials and project information.
- There's no production environment for now, but I'm planning to do it with webpack and embed most of the assets.
- In the future, it will also be possible to distribute it by Electron (desktop) and/or Ionic (mobile).
- **Join us at [GSHC discord](https://discord.gg/jwKJDXC)** (#programming channel) for discussion about the project.

## Running GS-HTML5 on your computer

In order to run GS-HTML5 in your computer, just clone the project and run it into a http server. I would recommend these steps:
- Clone the project (or download it and extract the files);
- Download [node.js](https://nodejs.org/en/download/) and install it (make sure you add node.js in the system path, default install should do it);
- In the terminal of your computer, install a light http server by running `npm install http-server -g`;
- In the terminal, go to the root folder (use `cd` command: `cd path\to\gshtml5`) of the GS-HTML5 you cloned/downloaded and then run `http-server -c-1 -o`;
- If the browser didn't open automatically, go to your browser (prefer Chrome based browsers) and access the address shown in the terminal (it's probably `http://localhost:8080/`).

## For developers

GS-HTML5 supports both Javascript and Typescript. We use [Webpack](https://webpack.js.org/) to build the bundle and serve the development environment.
- I strongly reccomend using [Visual Studio Code](https://code.visualstudio.com/download) to develop.
- Install dev dependencies by running `npm install` in the root folder.
- Use `npm start` to start the development server.
- Use `npm run build` to generate a bundle.
- Use these [guidelines](https://typedoc.org/guides/doccomments/) to comment code.

## Utils

Some useful tools that I use to manage the resources:
- [Visual Studio Code](https://code.visualstudio.com/download) (for developing the game)
- [TexturePacker 4.6.1](https://www.codeandweb.com/texturepacker) (for creating spritesheets)
  - [Sprite Sheet Packer](https://www.codeandweb.com/free-sprite-sheet-packer) (free alternative for TexturePacker)
- [PhysicsEditor 1.6.3](https://www.codeandweb.com/physicseditor) (for creating collision structures)
  - [LoonPhysics](https://loonride.com/physics) (free alternative for PhysicsEditor)
- [Tiledmap Editor 1.1](https://www.mapeditor.org/) ([Tiledmap version problem fix](https://github.com/bjorn/tiled/issues/2058#issuecomment-458975579)) (for building maps)
- [Shoebox](https://renderhjs.net/shoebox/) (for creating fonts)
- [Golden Sun Editor](http://forum.goldensunhacking.net/index.php?action=downloads;sa=view;down=124) (for game info)
- [Paint.NET](https://www.getpaint.net/) (for images editing)
- [XnConvert](https://www.xnview.com/en/xnconvert/) (for batch image convertion)

## Credits
- **http://www.goldensunhacking.net/** (This project would be impossible without these guys)
- https://gamefaqs.gamespot.com/gba/561356-golden-sun-the-lost-age/faqs
- http://www.goldensun-syndicate.net/sprites/
- https://www.spriters-resource.com/game_boy_advance/gs/
- https://www.spriters-resource.com/game_boy_advance/gs2/
- Golden Sun is copyright 2001-2003 Nintendo / CAMELOT.

All Golden Sun games and their media are property of Camelot Software Planning Ltd., Nintendo and/or Nintendo of America Inc., and are protected by United States and international copyright, trademark and other intellectual property laws.


text:
# with-playwright

[![Release](https://github.com/Xiphe/with-playwright/actions/workflows/release.yml/badge.svg)](https://github.com/Xiphe/with-playwright/actions/workflows/release.yml)
[![codecov](https://codecov.io/gh/Xiphe/with-playwright/branch/main/graph/badge.svg?token=944RNOA6PT)](https://codecov.io/gh/Xiphe/with-playwright)
[![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)

opt-in playwright browsers for testing

## Installation

```bash
npm install playwright with-playwright
```

## Usage

```ts
import withPlaywright from 'with-playwright';

withPlaywright(
  async (name, pw) => {
    const { browser, context, page } = await pw;
    /* Callback is not called when no browsers are configured */
    await page.goto('http://whatsmyuseragent.org/');
    await page.screenshot({ path: `example-${browserType}.png` });
    await browser.close();
  },
  {
    browsers: ['chromium', 'firefox', 'webkit'],
  },
);
```

## Configuration

Instead passing browsers in the config object, these can be
set using environment variables `WITH_PLAYWRIGHT_BROWSERS` or `BROWSERS`

```bash
BROWSERS=chromium,firefox,webkit ./myScriptWithPlaywright.js
```

If no browsers are set, the callback passed to `withPlaywright` is not
executed.

The idea is to use this in test runners like jest and use environment variables
to opt-into the slower tests that require a real browser.

## License

> The MIT License
>
> Copyright (C) 2020 Hannes Diercks
>
> Permission is hereby granted, free of charge, to any person obtaining a copy of
> this software and associated documentation files (the "Software"), to deal in
> the Software without restriction, including without limitation the rights to
> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
> of the Software, and to permit persons to whom the Software is furnished to do
> so, subject to the following conditions:
>
> The above copyright notice and this permission notice shall be included in all
> copies or substantial portions of the Software.
>
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: Xiphe/with-playwright

repo_name: Xiphe/with-playwright


text:
{
  "More Information" -> {
      "A Tensor's TensorName is used for caching.",
      "Automatically generated TensorNames end in -Auto.",
      "A TensorName that ends in -Auto is not cached.",
      "If no TensorDisplayName is given when a Tensor is formed, \
the TensorName will be used for the TensorDisplayName also."
  },

  "Basic Examples" -> {
    "gS = ToMetric[\"Schwarzschild\"]",
    "TensorName[gS]",
    "ricS = RicciTensor[gS]",
    "TensorName[gS]",
    "dgS = CovariantD[gS,-\[Gamma]]",
    "TensorName[MergeTensors[dgS]]"
    },

    "See Also" ->
    {"TensorDisplayName"},

    "Tutorials" -> {
      "Introduction to GeneralRelativityTensors",
      "Caching Tensor values"
    }

}

gha_language: Mathematica