text:
---
# Course title, summary, and position.
linktitle: "glide.workflow.user_approval_history"
summary: ""
weight: 1
# Page metadata.
title: "glide.workflow.user_approval_history"
date: "2018-09-09T00:00:00Z"
lastmod: "2018-09-09T00:00:00Z"
draft: false  # Is this a draft? true/false
toc: true  # Show table of contents? true/false
type: docs  # Do not modify.

# Add menu entry to sidebar.
# - name: Declare this menu item as a parent with ID name.
# - weight: Position of link in menu.
menu:
  properties:
    parent: Properties
    name: "glide.workflow.user_approval_history"
    weight: 1
---

Description: Log user approval activity - such as requested, approved and rejected - in the Approval History journal when using workflows to manage the approvals for a task.

Value: `false`

repository: akhiltony/sn

repo_name: akhiltony/sn


text:
Chef Network Visualiser
=======================

Also known as "the bouncy thing".

This little application was written over the course of a weekend during Christmas 2015.
The application came about because I wanted to see the Network schema from the viewpoint of the nodes registered with our Chef server.
There were hard coded elements so that I could see how the Network topology was organised.
For example
* load balancer connect to application firewall
* application firewall connect to varnish servers
* varnish servers connect to web servers ... etc

## Requirements

You will need
* [Ruby](https://www.ruby-lang.org/en/documentation/installation/) installed or Chef or [ChefDK](https://downloads.chef.io/chefdk)
* [Bundler](http://bundler.io/)

Optional
* Access to a Chef server with Chef client configuration file

## Installation

Clone or download the source code.

Go to the root of this application and use bundler to install gems

```
$ bundle install
```

This project was originally built on a Windows 8 (then 10) laptop and the Gemfile.lock contains win32-api gem.

If using Linux then update the bundle with
```
$ bundle update
```

## Running

This application is built on top of [Sinatra](http://sinatrarb.com/), a [RACK](https://rack.github.io/) friendly application.
Run the web application with bundle exec

```
$ bundle exec rackup
```

The application will look for a Chef client configuration file in the following locations
* Root of this folder
* ~/.chef (users home folder, then .chef folder)

The command line should inform whether it is using a Chef client configuration file (client.rb or knife.rb) or using Chef zero for the purposes of demo.

![Image of application run with bundle exec rackup](images/show_config.png)

The command line will also tell you which port the application is running on (default 9292).

Open a browser, enter the address as localhost plus the port the application is running on, press return and the index.html page will fire up ...

![Image of browser with index page loaded](images/index_in_browser.png)

## Usage

The application has two modes out of the box
* View network by Chef Roles
* View network by Chef Environments

To switch between the modes you'll have to alter the code in application.rb, only one view can be active at any one time.

The first thing to do is select Role/Environment from the Cloud drop down.

![Image of cloud selection](images/select_cloud.png)

After selecting the Role or Environment the matching nodes should appear.

![Image of network nodes](images/network_nodes.png)

From now you'll be able to
* Click a node to obtain more detail (displayed in the right hand pane)
* Search for a node/Role/Environment using the Search text box
* Put cursor on the nodes and flick them about (the bouncy thing)

## Ruby versions

Works with Ruby versions
* 1.9.3
* 2.3.1p112 (2016-04-26 revision 54768) [i386-mingw32]
* ruby 2.4.2p198 (2017-09-14 revision 59899) [x64-mingw32]

## Other

This was written for demo purposes / fun, code is not production ready, may contain bugs, does not contain nuts, some enjoyment maybe possible with the bouncy thing.

If you like this application or wish to improve it then please feel free to do so.

Next: An improved UI? ... to be continued.

repository: chrisgit/chef-network-visualiser

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: chrisgit/chef-network-visualiser


text:
# Cloudtrail Security checking

Enables AWS Config and adds managed config rules with good defaults.
The following AWS Config Rules are supported:

* acm-certificate-expiration-check: Ensure ACM Certificates in your account are marked for expiration within the specified number of days.
* cloudtrail-enabled: Ensure CloudTrail is enabled.
* ec2-volume-inuse-check: Checks whether EBS volumes are attached to EC2 instances
* guardduty-enabled-centralized: Checks whether Amazon GuardDuty is enabled in your AWS account and region.
* instances-in-vpc: Ensure all EC2 instances run in a VPC.
* root-account-mfa-enabled: Ensure root AWS account has MFA enabled.
* rds-storage-encrypted: Checks whether storage encryption is enabled for your RDS DB instances.
* s3-bucket-public-write-prohibited: Checks that your S3 buckets do not allow public write access.

- Terraform `0.13.+`

And more...

## How to use

- The module has a lot of variables (needed) setting by default, see `variables.tf` for more information and custom configuration.

```hcl
module "security-checking" {
  source                 = "hendrixroa/config-security-check/aws"
  config_logs_bucket     = aws_s3_bucket.mybucket.bucket
  config_aggregator_name = "My Organization"
}
```


text:
---
layout: post
title: SunPy Update - March 2016
author: Stuart Mumford

---

Hello all,

Once again I am a week late, but here is a quick recap.

# February News

## Unified Downloader aka Fido

We had a very successful sprint on the Unified downloader a couple of weeks ago, and progress is being made towards having it ready to be merged. The two main things that need to be completed now are adding extra tests of the clients through the Fido interface and improving the documentation.

We are maintaining a list of issues outstanding on the unidown branch [here](https://github.com/sunpy/sunpy/issues?q=is%3Aissue+is%3Aopen+label%3Aunidown) as always feel free to ask for advice if you would like to tackle any of them.  Fido is a key feature of SunPy 0.7 and will permit the development of the LightCurve object.

## Google Summer of Code

[OpenAstronomy](http://openastronomy.org) got accepted as a GSOC 2016 mentoring Organisation.  This is a significant new development as it indidcates outside recognition of the maturity and quality of the efforts comprising Open Astronomy (SunPy's previous GSOC students came via the Python Foundation as the mentoring Organisation).  This is the first time in 4 years thathe GSOC Org application SunPy has put in (individually or as a team) has been accepted! What this means for SunPy is that we will get some money per student from Google.

For more information on GSOC see the [OpenAstronomy](http://openastronomy.org) website, and it's not too late to submit project ideas.

# Coming up in March

## Python in Astronomy 2016

The Python in Astronomy conference is running between the 21st and the 25th of March at the e-Science Institute at the University of Washington in Seattle.
There will a strong SunPy contingent attending, keep your eyes open on social media and on the internet for talks and materials from the conference.
There will be no meeting on the 21st March due to this conference.

## Weekly Developer Discussions

The weekly meetings will be continuing this month, they are at 1700UTC each
week. We are using Google Hangouts and you can be notified of them by following
our Google+ page (normally the join link is posted in IRC once the meeting has
started). These meetings are also recorded and uploaded to YouTube, so you can
catch up even if you can not attend in person.

Links to coming meetings can are below:

- 7/3 [https://plus.google.com/events/cjoctfv55r7220lj0ffdv636tng](https://plus.google.com/events/cjoctfv55r7220lj0ffdv636tng)
- 14/3 [https://plus.google.com/events/ccinoddrb5mhi8l58vu1ah2ti5s](https://plus.google.com/events/ccinoddrb5mhi8l58vu1ah2ti5s)
- 21/3 There will be no meeting this week due to Python in Astronomy 2016.
- 28/3 [https://plus.google.com/events/cjiuftsuopsdc7v374qpe1khvl0](https://plus.google.com/events/cjiuftsuopsdc7v374qpe1khvl0)

## Reviewing Pull Requests

As always, reviews on pull requests are always welcome, you don’t have to have
merge permissions or anything other than a GitHub account to review PRs. You can
find a list of all the PRs that need reviewing [here](https://github.com/sunpy/sunpy/labels/%5BReview%5D).

## Getting in touch

Finally, I wanted to remind everyone about our public communication methods. We
have two mailing lists, SunPy and sunpy-dev, the main SunPy list is used for
general questions and announcements, and the sunpy-dev list is used for
developer discussion and organisational emails. We also have the IRC channel
(#SunPy on Freenode), which normally has someone hanging out in it, and is an
excellent place to get some real-time help, or to just come for a chat. We also
have our Google+ page and a Twitter account.

Happy Pythoning,
Stuart

license: MIT


text:
---
title: 'init - CLI command'
description: 'Adds nx.json file and installs nx if not installed already'
---

# init

Adds nx.json file and installs nx if not installed already

## Usage

```terminal
nx init
```

Install `nx` globally to invoke the command directly using `nx`, or use `npx nx`, `yarn nx`, or `pnpm nx`.

repository: bradtaniguchi/nx

gha_license_id: MIT

repo_name: bradtaniguchi/nx


text:
[![DOI](https://zenodo.org/badge/27440980.svg)](https://zenodo.org/badge/latestdoi/27440980)

![HAROS](logo.png?raw=true "HAROS Logo")

HAROS is a framework for quality assurance of ROS-based code, mostly based on **static analysis** - which consists on *extracting information* from the source code *without executing it* (and, sometimes, even without compiling it).
Its main goal is the **early detection of problems** in the software development life cycle, which would otherwise go unnoticed into later stages or even into production.

**Try it yourself:** there is a demo page of the HAROS visualizer available on [GitHub](https://git-afsantos.github.io/haros).

**Tutorials:** [on GitHub](https://github.com/git-afsantos/haros_tutorials/) and [on YouTube](https://youtube.com/playlist?list=PLrXxXaugT0cwVhjhlnxY6DU0_WYPLEmgq).

**More info:** short video presentation [on YouTube](https://www.youtube.com/watch?v=s_Zmch8xjzQ).

## Current Status

HAROS is still being developed, as of August 2021.
Help improve HAROS by participating in a short [user survey](https://docs.google.com/forms/d/e/1FAIpQLSdD0nC2tb_IBjvasoWDOR_LzplTYF4cGkI5ZQqJtgDAe8ZQsQ/viewform?usp=sf_link).

## Installing

See [INSTALL](./INSTALL.md) for installation methods and instructions.

## How to Use

See [USAGE](./docs/USAGE.md) for basic commands and usage instructions.

## Bugs, Questions and Support

Check whether your question has an answer in the [FAQ](./docs/FAQ.md).

Please use the [issue tracker](https://github.com/git-afsantos/haros/issues) for issues or feature requests directly related to HAROS.

For issues related to plugins, please use the respective plugin repository.

If you run into errors, or feel that something is not working, run HAROS in debug mode, so the log files do not miss any information, e.g.,

```
haros --debug analyse ...
```

Then, you can share the log file, found by default within `~/.haros/log.txt`.

## Citing

See [CITING](./CITING.md).

## Contributing

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

## Acknowledgment

Until March 2021, this work was financed by the ERDF – European Regional Development Fund through the Operational Programme for Competitiveness and Internationalisation - COMPETE 2020 Programme and by National Funds through the Portuguese funding agency, FCT - Fundação para a Ciência e a Tecnologia within project PTDC/CCI-INF/29583/2017 (POCI-01-0145-FEDER-029583).

repository: git-afsantos/haros

gha_language: Python

repo_name: git-afsantos/haros


text:
---
layout: default
---

# 1995-11-16 - Re: Netscape rewards are an insult

## Header Data

From: Jeff Weinstein<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 760d0a9afae58b0f32b4ac02fc3b83d0df464efd8144f457134e4387642d234d

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1995-11-16 04:29:08 UTC

Raw Date: Wed, 15 Nov 95 20:29:08 PST

## Raw message

```
{% raw  %}From: Jeff Weinstein<EMAIL_ADDRESS>Date: Wed, 15 Nov 95 20:29:08 PST
To<EMAIL_ADDRESS>Subject: Re: Netscape rewards are an insult
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Perry E. Metzger wrote:
>
> Jeff Weinstein writes:
> > All of these security measures are implemented by Netscape in the
> > current release.  Specifically, Netscape Navigator 2.0beta2
> > includes all the applet security precautions detailed in the recent
> > comp.lang.java posting.  Netscape has been shipping the fixed
> > applet security model for over a month(since 2.0Beta1), and
> > Netscape and Sun continue to cooperate and work closely on applet
> > security issues.
>
> I've got to note just one thing -- every Netscape 2.0beta2 I've used
> has been so full of bugs, and so prone to problems, that I have my
> wonders about what the security code looks like. I know, Jeff, that
> its all done by different groups -- but the Java stuff I've run in
> 2.0beta2 is so weirdly different than the supposedly compatible stuff
> I've run under HotJava -- especially when it comes to crashing (and it
> HAS crashed on me) that I have serious worries about the security of
> the thing. I'd say the quality looks very much like an alpha release,
> not "beta". I don't want to turn this to Javapunks so I won't say more
> on this topic any time soon -- its already been beaten into the
> ground.

  The version of Java in Netscape is not compatible with the version of
Java in the summer release of HotJava.  There were incompatible changes
made by Sun between their alpha(summer HotJava) and beta (Netscape 2.0
and Sun's JDK Beta).  As I understand the situation, applets that were
written for HotJava must be ported to the beta API for them to work
with more recent releases of Java.

  I would agree that Java is not as stable as the rest of the 2.0 release.
That is one reason why we have added a preference to disable Java.
  I argued for
this switch because I knew that there would be people who would not
want to trust Java until it had some mileage on it.

  The early beta releases we do are mostly intended for developers and
early adopters who want early access to the new features.  We had a
great leap in quality between B1 and B2, and I expect that to continue
with the future betas.

	--Jeff

--
Jeff Weinstein - Electronic Munitions Specialist
Netscape Communication Corporation
<EMAIL_ADDRESS>- http://home.netscape.com/people/jsw
Any opinions expressed above are mine.

{% endraw %}
```

## Thread

+ Return to [November 1995](/archive/1995/11)

+ Return to "[anonymous-remailer@shell.portal.com](/authors/anonymousremailer_at_shell_portal_com)"
+ Return to<EMAIL_ADDRESS>(Dr. Frederick B. Cohen)](/authors/fc_at_all_net_dr_frederick_b_cohen_)"
+ Return to "["Harry S. Hawk" <habs@warwick.com>](/authors/harry_s_hawk_habs_at_warwick_com_)"
+ Return to "[Jeff Weinstein <jsw@netscape.com>](/authors/jeff_weinstein_jsw_at_netscape_com_)"
+ Return to "[Matthew James Sheppard <Matthew.Sheppard@Comp.VUW.AC.NZ>](/authors/matthew_james_sheppard_matthew_sheppard_at_comp_vuw_ac_nz_)"
+ Return to "["Perry E. Metzger" <perry@piermont.com>](/authors/perry_e_metzger_perry_at_piermont_com_)"
+ Return to "[Ray Cromwell <rjc@clark.net>](/authors/ray_cromwell_rjc_at_clark_net_)"

+ 1995-11-15 (Wed, 15 Nov 1995 18:29:34 +0800) - [Re: Netscape rewards are an insult](/archive/1995/11/54e4218a982ae9e09e743724f0dcfd9ab13b95da0377a34b0c77b24bdbdb52cd) -<EMAIL_ADDRESS>  + 1995-11-15 (Wed, 15 Nov 95 04:18:56 PST) - [Re: Netscape rewards are an insult](/archive/1995/11/0f2255c51ebd0558b827dd82b8d7fa54574cae841c63fe3a207a0d763a5a23a4) -<EMAIL_ADDRESS>(Dr. Frederick B. Cohen)_
    + 1995-11-15 (Wed, 15 Nov 1995 23:26:44 +0800) - [Re: Netscape rewards are an insult](/archive/1995/11/3d96b91e3776d5fd09aef8a23cc0fc4af4f9f8bbeebdabf0a98997c1210af214) - _Ray Cromwell<EMAIL_ADDRESS>  + 1995-11-16 (Thu, 16 Nov 1995 10:58:55 +0800) - [Re: Netscape rewards are an insult](/archive/1995/11/05d12f7c2ac0ce057b1ea80308cea766050287c1a78a8cfed1ac280c23e24494) - _Jeff Weinstein<EMAIL_ADDRESS>    + 1995-11-16 (Thu, 16 Nov 1995 11:41:42 +0800) - [Java Security Class in Netscape (was: Netscape rewards are an insult)](/archive/1995/11/138390664aa2fc307bba50978205d401a7870a91c1cff576f1d58fc74aa09c6c) - _"Harry S. Hawk"<EMAIL_ADDRESS>    + 1995-11-17 (Fri, 17 Nov 1995 15:33:14 +0800) - [Re: Netscape rewards are an insult](/archive/1995/11/129ba6133b18c52d1f2750df5e400bdf3c544690f84aef0724b6ab8debfc38de) - _"Perry E. Metzger"<EMAIL_ADDRESS>      + 1995-11-16 (Wed, 15 Nov 95 20:29:08 PST) - Re: Netscape rewards are an insult - _Jeff Weinstein<EMAIL_ADDRESS>      + 1995-11-17 (Fri, 17 Nov 1995 09:47:26 +0800) - [Re: Netscape rewards are an insult](/archive/1995/11/51812ab96fcc9811617ad64a266f9e0d7902d0a8878f0e1451f3c9875aa175b2) - _Matthew James Sheppard<EMAIL_ADDRESS>      + 1995-11-17 (Fri, 17 Nov 1995 17:17:12 +0800) - [Re: Netscape rewards are an insult](/archive/1995/11/26fcc2706ce08ed3e3c9cc8e19cac113fc011e91689467285b9b44c35b0dd454) - _Jeff Weinstein<EMAIL_ADDRESS>


text:
## Installation and Quickstart
If you have Sphere Core installed, then

    % spheres install fusion

Otherwise, please read the [quickstart guide](http://www.schemespheres.org/guides/en/quickstart).

### Android support

You need the Android SDK and NDK, an the following variables set:

* ANDROID_SDK_PATH=your_path_to_the_sdk
* ANDROID_NDK_PATH=your_path_to_the_ndk

Then you can compile Gambit for Android using the following script:

    % sh tools/build_android_lib.sh

You might have to edit the script to set the proper paths if you get an error. However, in any case it will break when trying to compile gsi, but you don't need it. You only need _libgambc.a_, copy it from lib/libgambc.a include/gambit.h include/gambit-not{gambit-version}.h to android/jni/gambit

### Updating Gambit System

Follow this process:
* Recompile Gambit for the host
* Recompile Gambit for the Android architecture, and copy the libgambc.a generated file to android/jni/gambit

If you get a segmentation fault with Gambit when loading a module that is precompiled, probably it was compiled with a different Gambit version

[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/alvatar/sphere-fusion/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

license: Zlib

repository: fjvallarino/sphere-fusion

repo_name: fjvallarino/sphere-fusion


text:
# Staticli

[![Download](https://img.shields.io/github/release/staticli/staticli.svg?label=download)](https://github.com/staticli/staticli/releases/latest)

A CLI tool for working with static site generators.  A [Cali](https://github.com/skybet/cali) App

This application provides a number of tools related to static site generation, all running in docker containers from a single binary file.  Rather than go through the hassle of installing Ruby, rake, bundler, jekyll, python, proselint, gulp, etc. you only need the one single binary file and to have docker installed.

## Tools

Staticli provides the tools that its developers regularly use to work with static websites.  We're open to pull requests for additional tooling, but it must be relevant to static web site development (feel free to create your own Cali app for other tools).  The tools we currently provide include:

* bundle and rake for working with Jekyll and github-pages websites
* github-release for releasing a new version of something to github
* gulp for compiling scss to css
* heroku for deploying sites to heroku
* hugo for providing the hugo static site generator
* jekyll for creating new jekyll sites
* mkdocs, a fast and simple static site generator that's geared towards building project documentation
* npm and npx for managing and running node packages
* ponysay for nice notifications
* proselint for checking files for best practises in writing
* python simplehttp for serving the current directory over http
* surge for deploying sites to surge.sh

## Installation

1. Install Docker (`brew cask install docker` on MacOS)
2. Download the [correct binary](https://github.com/staticli/staticli/releases/latest), move it into your $PATH as `staticli` and make it executable

See this [asciicast](https://asciinema.org/a/159883) to watch it being installed

## Usage

From this one single binary you can now run rake tasks to preview and validate Jekyll blogs, run proselint to check for best practises in writing, and run gulp to turn sass into css.  All of this happens inside docker containers, so you don't actually need to install any extra tooling.  You will need an internet connection the first time you run each subcommand in order to download the container though.

For any command which exposes a port (typically an http server to render a site) we default to exposing this on port 2000.  You can override this by setting `--port 4000` or `-p 4000` to listen on (for example) port 4000 instead.

`staticli ag` runs Silver Searcher in the current directory.

`staticli rake` runs `bundle install --path=_vendor && bundle exec rake $@` in the current directory.  This assumes the default rake task runs preview on a Jekyll site, and therefore exposes port 4000 on the container as port 2000 on the host.  This means you can browse to http://<IP_ADDRESS>:2000 to view the site.  You can change the port exposed on the host by setting `--port 4000` to use (for example) port 4000.

`staticli bundle` runs `bundle` in the current directory.  Since the `rake` command installs required gems anyway, this command is mostly useful as a way of upgrading gems.

`staticli gulp` runs the gulp watch task.  You can add `-t foo` to run the foo task instead.

`staticli heroku` runs the Heroku cli, and takes any parameters and subcommands you need (uses ~/.netrc for authentication)

`staticli hugo` runs the hugo static site generator

`staticli mkdocs new .` creates a new static website for project documentation, `staticli mkdocs serve` will serve it (though note you'll need to set dev_addr)

`staticli npm` runs npm, the node package manager, and `staticli npx` runs npx from it

`staticli ponysay` runs ponysay, a cowsay replacement for ponies.  Whilst this isn't strictly speaking a static site generator, it can be useful for notifying that we've finished generating a static site

`staticli proselint README.md` runs proselint against the file README.md to check for best practises in writing.

`staticli simplehttp` runs Python SimpleHTTP in the current directory.

`staticli surge` runs surge, allowing you to deploy the current directory to a surge.sh site.

`staticli github-release` for releasing something to github (see the Makefile for how this is used, it's probably not that helpful except for releasing new versions of staticli)

You can also see what version of staticli you are running with `staticli version` which will also tell you about any available updates if you are online.  If there are available updates you can get the latest version with `staticli update`.  You can also use `staticli update` to update all of the local Docker images that Staticli uses by passing in `-i`.

See this [asciicast](https://asciinema.org/a/159884) to see proselint being used for the first time.

[![Download](https://img.shields.io/github/release/staticli/staticli.svg?label=download)](https://github.com/staticli/staticli/releases/latest)

## Development

Travis will automatically build and release new versions upon a new tag being pushed.  When you want to create a new release, create a new tag against the master branch (incrementing as per the [SemVer](https://semver.org/) standard) and then push it.

repository: staticli/staticli

gha_language: Go

repo_name: staticli/staticli


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

## [Unreleased]

## 0.2.0 - 2018-12-31
### Added
- String multiplication

## 0.1.0 - 2018-08-16
### Added
- project started as gradle/kotlin for Java 8+
- OperatorHelper for creating your own multiplication functions based on a given addition function and an optional neutral element (s. https://en.wikipedia.org/wiki/Identity_element)
- Modifications adds multiplication for Lists; this multiplication function must be imported when used

[Unreleased]: https://github.com/Joachimalaya/operators/compare/0.1.0...HEAD

repository: Joachimalaya/operators

repo_name: Joachimalaya/operators


text:
# heart_rate_sentinel_server

This code works by sending 'requests.get' or 'requests.post' to
the server. The user can post patient information (patient_id,
attending_email, user_age) to the server that stores the data
into a Mongo database. The user can then post heart rate data
to the server along with the user_id, to add heart rate data
to an existing patient.

The user can then make get requests to determine the following:
list of all heart rates, average heart rate over all values,
average heart rate since a given time, and the status of the
patient to determine if they are tachycardic. In order to get
this information the user must input the user_id, in order for
the server to access the information on that user.

When determining if the patient is tachycardic, if the result
comes back 'true' (they are tachycardic) an email is sent to
the patient, using the email associated with their data.

In order to determine the average since a given time, the user
must make a request post with the user_id, and specified time
using te UTC time stamp.


text:
---
{
  "title": "from roots to shoots", "url": "from-roots-to-shoots", "date": "23 June
  2020", "summary": "How do trees 50 meters tall get water from their roots all the way to
  their shoots? (Hint: it's not just capillary action).."
}
---
# Water transport in trees

- tangential tidbits
  - https://en.wikipedia.org/wiki/Guttation
  - https://en.wikipedia.org/wiki/Xylem
  - https://en.wikipedia.org/wiki/Pressure

- What is capillary action and how does it work?
  - https://en.wikipedia.org/wiki/Capillary_action
  - adhesion and cohesion of water
    - https://www.usgs.gov/special-topic/water-science-school/science/adhesion-and-cohesion-water?qt-science_center_objects=0#qt-science_center_objects
  - pressure head
    - https://en.wikipedia.org/wiki/Pressure_head

- What are the hypotheses?
  - http://bio1520.biology.gatech.edu/nutrition-transport-and-homeostasis/plant-transport-processes-i/
  - https://www.nature.com/scitable/knowledge/library/water-uptake-and-transport-in-vascular-plants-103016037/
  - https://en.wikipedia.org/wiki/Ascent_of_sap
  - root pressure
    - https://www.britannica.com/science/root-pressure
    - https://en.wikipedia.org/wiki/Root_pressure
  - transpiration
    - https://www.ncbi.nlm.nih.gov/pmc/articles/PMC55440/
    - https://en.wikipedia.org/wiki/Transpiration
  - cohesion-tension
    - https://watermark.silverchair.com/48-10-1753.pdf?token=AQECAHi208BE49Ooan9kkhW_Ercy7Dm3ZL_9Cf3qfKAc485ysgAAApYwggKSBgkqhkiG9w0BBwagggKDMIICfwIBADCCAngGCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQMaAjvZ-arsoe-Dx59AgEQgIICSVQYhHXkpfmcn7JM9PSVV1KKPTSnPvDEwTgUA0VFJSfgZRUQSXN-EqAxxWcG4OsqMg3RB9sRf30GuDTcqu_lW1XvymOZYEnjl_TmVdq-3UXVEko8u7uAsQkAqNDyZuqSYAA0QEgVOsEXgcH2dAFLcNFsmbzLNUhuveR8sCoQhj_1hQ1_CLmKdNnQlmjuPat-YXHe7lTTTr3zzqnagi6l2AbOGaToo6BKYqqVBvy8RL06jW7HYXwZorOOeyZRwTC4wWv8LKezVy6uzPcQNqkv9g5CHRYqQfOCI48LRQQMUX_2mwTN2lx3NIkABgmBMMKIeWbGKBVsksIv5KKc371s0cFaNHYVvGM18pqE21cQ5jOxMvy9CmnHs2fBtkwbMZ6FzeAVq2WI8advpt8R7S4lhUogX5VBukAHLJUAAM4iM3Ow7D_WyKeRODNTqvtJRYbzXjg7A_0MpBMWMWXVX09N8Kc39iVtsX2H1JeNxPBJKYopN3JbZvI6o75DGICwHZz2n1bupXVkpDisRaLxHrHrOKkmYyrhLKMQ4U9de_nNITujihNxObTnVhktm7q1rvAIU4Ss06z8xMJ0_3Lrn_oFauLRW-kkwsTs4yx7O5Kl9oKVA5pVYzcL7b044V0vKOBX15z4FvicGbkfXAkWXq-Ziqg1LUQc6OeBO6NNLo8Cfq5u-q3CFpbEPdlev_ZAazah3sUnDDo6DmJuNhMIne_CsvwIfQLds9Z0g0k6kl8VhhM6kQ1MLMLWbn8OwdCxEUfOEDf1oio2U2q4Sw
  - capillary action

## Capillary Action

"Is the ability of a liquid to flow in narrow spaces without the assistance of, or even in
opposition to, external forces like gravity."
  e.g. a fountain pen nib or how liquid moves throughout a paper towel

It's essentially just the combination between cohesion and adhesion. In that the liquid cells
close to the sides adheres to the container wall (adhesion), and pulls neighboring cells
with it (cohesion).

We've known about this since 1660

Governed by the formula (Jurin's Law):
  h = (2 * gamma * cos(theta)) / (rho * g * r),
    where,
      h:      max height of liquid from capillary action
      gamma:  liquid-air surface tension
      theta:  contact angle (???)
      rho:    density of the liquid
      g:      gravity
      r:      radius of the tube

  for water this works out to:
    h ~ (1.48 * 10^-5 m^2) / r

What is capillary action?

The ability of a liquid to flow in narrows spaces without the assistance of external
forces due to cohesion and adhesion.

Cohesion is the manifestation of the bonding electrostatic force of similar molecules, and
adhesion is the bonding electrostatic force of dissimilar molecules (things and cohere and
adhere for reasons other than the electrostatic force, but in trees this is the case).

repository: camenpihor/website

gha_language: Jupyter Notebook

repo_name: camenpihor/website


text:
# Blacksmith Dashboard

The Blacksmith Dashboard enables organizations to have a complete view of their
data engineering solution, on top of [Blacksmith](https://nunchi.studio/blacksmith).

![Blacksmith Dashboard](https://nunchi.studio/images/blacksmith/dashboard.002.png)

The source code of this repository is compiled and exported to be the built-in
dashboard of applications leveraging Blacksmith. It is only available when using
the [Enterprise Edition](https://nunchi.studio/blacksmith/pricing).

To make forks and customization as easy as possible, this repository is available
as an open-source "template" repository.

## Usage

First, you need to create a `.env` file at the root directory of the repository.
It shall be based on the `.env.example` already present.

Then, install dependencies with `npm`:
```bash
$ npm install
```

Finally you can start the dashboard. In development:
```bash
$ npm run dev
```

Or in production:
```bash
$ npm run build
$ npm run start
```

## Version compatibility

This package follows the semantic versioning of [Blacksmith](https://github.com/nunchistudio/blacksmith)
for major and minor versions. For example, the dashboard `v0.18.x` will be compatible
with Blacksmith `v0.18.x`.

## License

Repository licensed under the [Apache License, Version 2.0](./LICENSE).

By downloading, installing, and using Blacksmith, you agree to the
[Blacksmith Terms and Conditions](https://nunchi.studio/legal/terms).

branch_name: refs/heads/main


text:
# Contribute

This document provides information for developers who wish to contribute to the **vscode MOCA Client** project.

## Building

#### Node.js
vscode extensions are built with node.js; any version >= 10 should be okay.

#### Dependencies
npm is used for dependency management. Dependency information can be found in `package.json`.

#### Clone and run
Once repository is cloned, you will need to install dependencies. This can be done by running
```powershell
npm install
```
command in project root directory via terminal.

After dependencies are installed, pressing `F5` will run default configuration.

## Testing

If **not** testing new MOCA Language Server build, you can just run and debug normally.

If testing new MOCA Language Server build, place fat jar in `/bin` directory and make sure that `MOCA_LANGUAGE_SERVER_VERSION` in `src/extension.ts` matches fat jar version in `/bin` before running/debugging.

## Debugging

No special instructions -- breakpoints can be placed where desired and stepped through normally upon running via `F5`.


text:
# MhdViewer
A basic medical image (mhd) viewer based on VTK and DCMTK library

## Configuration
* `platform`: Windows 10 x64 version 1709
* `Visual Studio`: 2017 Professional
* `VTK`: 8.0.0
* `DCMTK`: 3.6.2+DEV

## Compile

### Step 1: Compile VTK Library

**DEBUG** or **RELEASE** mode.

### Step 2: Compile DCMTK Library

**DEBUG** or **RELEASE** mode.

### Step 3: Compile Project

**DEBUG**

| Setting | Items |
|---------|-------|
|`VC++ Directories->Including Directories(包含目录)`| F:\Program Files (x86)\VTK_DEBUG\include\vtk-8.0
 F:\Program Files (x86)\DCMTK\include\|
|`VC++ Directories->Library Directories(库目录)`| F:\Program Files (x86)\VTK_DEBUG\lib\
 F:\Program Files (x86)\DCMTK\lib\|
|`Linker->Input->Additional Dependencies(附加依赖项)`| charls.lib
 cmr.lib
 dcmdata.lib
 dcmdsig.lib
 dcmfg.lib
 dcmimage.lib
 dcmimgle.lib
 dcmiod.lib
 dcmjpeg.lib
 dcmjpls.lib
 dcmnet.lib
 dcmpmap.lib
 dcmpstat.lib
 dcmqrdb.lib
 dcmrt.lib
 dcmseg.lib
 dcmsr.lib
 dcmtls.lib
 dcmtract.lib
 dcmwlm.lib
 i2d.lib
 ijg12.lib
 ijg16.lib
 ijg8.lib
 oflog.lib
 ofstd.lib
|

*Note:* Keep the same compile mode (DEBUG or RELEASE) for VTK, DCMTK and current project.
*Note 2:* VTK libraries are added in `vtk_lib.h`

**RELEASE**
Omit...

*Note:* In `VTKdemo2.cpp`, instead of including `vtk_lib.h`, I add those libriries in `Linker->Input->Additional Dependencies`.

## Description

`VTKdemo.cpp` is the first edition of this project. It can open and display `.mhd` and `.dcm` files. This edition shows images just using VTK library, so it can easily read `.mhd` files. However, it can just read **single** series in one study (dicom).

`VTKdemo2.cpp` is the second edition of this project. I introduced DCMTK library which can process multi-series study and compressed dicom images. `myDicomImageReader.cpp/.h` is the core code to read compressed or multi-series dicom images.

`install.bat` is a processing batch, used to install VTK_demo.exe to system register table. After installation, you can open `.mhd` file according to double click and open `.dcm` folder with the item `Open with CTViewer` in context menu.

## Display

![image display](./image/image.png)


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# lgr

[![CRAN
status](https://www.r-pkg.org/badges/version/lgr)](https://cran.r-project.org/package=lgr)
[![Lifecycle:
maturing](https://img.shields.io/badge/lifecycle-maturing-blue.svg)](https://lifecycle.r-lib.org/articles/stages.html)

lgr is a logging package for R built on the back of
[R6](https://github.com/r-lib/R6) classes. It is designed to be
flexible, performant and extensible. The package
[vignette](https://s-fleck.github.io/lgr/articles/lgr.html) contains a
comprehensive description of the features of lgr (some of them unique
among R logging packages) along with many code examples.

Users that have not worked with R6 classes before, will find configuring
Loggers a bit strange and verbose, but care was taken to keep the syntax
for common logging tasks and interactive usage simple and concise. User
that have experience with [shiny](https://github.com/rstudio/shiny),
[plumber](https://github.com/rstudio/plumber), [python
logging](https://docs.python.org/3/library/logging.html) or [Apache
Log4j](https://logging.apache.org/log4j/2.x/) will feel at home. User
that are proficient with R6 classes will also find it easy to extend and
customize lgr, for example with their own appenders Loggers or
Appenders.

## Features

- *Hierarchical loggers* like in log4j and python logging. This is
  useful if you want to be able to configure logging on a per-package
  basis.
- An *arbitrary number of appenders* for each logger. A single logger
  can write to the console, a logfile, a database, etc… .
- Support for structured logging. As opposed to many other logging
  packages for R a log event is not just a message with a timestamp, but
  an object that can contain arbitrary data fields. This is useful for
  producing machine readable logs.
- *Vectorized* logging (so `lgr$fatal(capture.output(iris))` works)
- Lightning fast *in-memory logs* for interactive use.
- Appenders that write logs to a wide range of destinations:
  - databases (buffered or directly)
  - email or pushbullet
  - plaintext files (with a powerful formatting syntax)
  - JSON files with arbitrary data fields
  - Rotating files that are reset and backed-up after they reach a
    certain file size or age
  - memory buffers
  - (colored) console output
- Optional support to use [glue](https://glue.tidyverse.org/) instead of
  `sprintf()` for composing log messages.

## Usage

To log an *event* with with lgr we call `lgr$<logging function>()`.
Unnamed arguments to the logging function are interpreted by
`sprintf()`. For a way to create loggers that
[glue](https://glue.tidyverse.org/) instead please refer to the
vignette.

``` r
lgr$fatal("A critical error")
#> FATAL [20:38:17.998] A critical error
lgr$error("A less severe error")
#> ERROR [20:38:18.057] A less severe error
lgr$warn("A potentially bad situation")
#> WARN  [20:38:18.072] A potentially bad situation
lgr$info("iris has %s rows", nrow(iris))
#> INFO  [20:38:18.074] iris has 150 rows

# the following log levels are hidden by default
lgr$debug("A debug message")
lgr$trace("A finer grained debug message")
```

A Logger can have several Appenders. For example, we can add a JSON
appender to log to a file with little effort.

``` r
tf <- tempfile()
lgr$add_appender(AppenderFile$new(tf, layout = LayoutJson$new()))
lgr$info("cars has %s rows", nrow(cars))
#> INFO  [20:38:18.173] cars has 50 rows
cat(readLines(tf))
#> {"level":400,"timestamp":"2023-03-04 20:38:18","logger":"root","caller":"eval","msg":"cars has 50 rows"}
```

By passing a named argument to `info()`, `warn()`, and co you can log
not only text but arbitrary R objects. Not all appenders support
structured logging perfectly, but JSON does. This way you can create
logfiles that are machine as well as (somewhat) human readable.

``` r
lgr$info("loading cars", "cars", rows = nrow(cars), cols = ncol(cars))
#> Warning in (function (fmt, ...) : one argument not used by format 'loading cars'
#> INFO  [20:38:18.263] loading cars {rows: `50`, cols: `2`}
cat(readLines(tf), sep = "\n")
#> {"level":400,"timestamp":"2023-03-04 20:38:18","logger":"root","caller":"eval","msg":"cars has 50 rows"}
#> {"level":400,"timestamp":"2023-03-04 20:38:18","logger":"root","caller":"eval","msg":"loading cars","rows":50,"cols":2}
```

For more examples please see the package
[vignette](https://s-fleck.github.io/lgr/articles/lgr.html) and
[documentation](https://s-fleck.github.io/lgr/)

## See lgr in action

lgr is used to govern console output in my shiny based csv editor
[shed](https://github.com/s-fleck/shed)

``` r
# install.packages("remotes")
remotes::install_github("s-fleck/shed")
library(shed)

# log only output from the "shed" logger to a file
logfile <- tempfile()
lgr::get_logger("shed")$add_appender(AppenderFile$new(logfile))
lgr::threshold("all")

# edit away and watch the rstudio console!
lgr$info("starting shed")
shed(iris)
lgr$info("this will not end up in the log file")

readLines(logfile)

# cleanup
file.remove(logfile)
```

## Development status

lgr in general is stable and safe for use, but **the following features
are still experimental**:

- Database appenders which are available from the separate package
  [lgrExtra](https://github.com/s-fleck/lgrExtra).
- yaml/json config files for loggers (do not yet support all planned
  features)
- The documentation in general. I’m still hoping for more R6-specific
  features in [roxygen2](https://github.com/r-lib/roxygen2) before I
  invest more time in object documentation.

## Dependencies

[R6](https://github.com/r-lib/R6): The R6 class system provides the
framework on which lgr is built and the **only Package lgr will ever
depend on**. If you are a **package developer** and want to add logging
to your package, this is the only transitive dependency you have to
worry about, as configuring of the loggers should be left to the user of
your package.

### Optional dependencies

lgr comes with a long list of optional dependencies that make a wide
range of appenders possible. You only need the dependencies for the
Appenders you actually want to use. Care was taken to choose packages
that are slim, stable, have minimal dependencies, and are well
maintained :

Extra appenders (in the main package):

- [jsonlite](https://github.com/jeroen/jsonlite) for JSON logging via
  `LayoutJson`. JSON is a popular plaintext based file format that is
  easy to read for humans and machines alike.

- [rotor](https://github.com/s-fleck/rotor) for log rotation via
  AppenderFileRotating and co.

- [data.table](https://github.com/Rdatatable/) for fast in-memory
  logging with `AppenderDt`, and also by all database / DBI Appenders.

- [glue](https://glue.tidyverse.org/) for a more flexible formatting
  syntax via LoggerGlue and LayoutGlue.

Extra appenders via [lgrExtra](https://github.com/s-fleck/lgrExtra):

- [DBI](https://github.com/r-dbi/DBI) for logging to databases. lgr is
  confirmed to work with the following backends:

  - [RSQLite](https://github.com/r-dbi/RSQLite),
  - [RMariaDB](https://github.com/r-dbi/RMariaDB) for MariaDB and MySQL,
  - [RPostgres](https://cran.r-project.org/package=RPostgres),
  - [RJDBC](https://github.com/s-u/RJDBC) for DB2, and
  - [odbc](https://github.com/r-dbi/odbc) also for DB2.

  In theory all DBI compliant database packages should work. If you are
  using lgr with a database backend, please report your (positive and
  negative) experiences, as database support is still somewhat
  experimental.

- [gmailr](https://cran.r-project.org/package=gmailr) or

- [sendmailR](https://cran.r-project.org/package=sendmailR) for email
  notifications.

- [RPushbullet](https://github.com/eddelbuettel/rpushbullet) for push
  notifications.

- [Rsyslog](https://cran.r-project.org/package=rsyslog) for logging to
  syslog on POSIX-compatible systems.

- [elastic](https://cran.r-project.org/package=elastic) for logging to
  ElasticSearch

Other extra features:

- [yaml](https://CRAN.R-project.org/package=yaml) for configuring
  loggers via YAML files
- [crayon](https://github.com/r-lib/crayon) for colored console
  output.
- [whoami](https://github.com/r-lib/whoami/blob/master/DESCRIPTION) for
  guessing the user name from various sources. You can also set the user
  name manually if you want to use it for logging.
- [desc](https://CRAN.R-project.org/package=desc) for the package
  development convenience function `use_logger()`
- [cli](https://CRAN.R-project.org/package=cli) for printing the tree
  structure of registered loggers with `logger_tree()`

Other `Suggests` ([future](https://CRAN.R-project.org/package=future),
[future.apply](https://CRAN.R-project.org/package=future.apply)) do not
provide extra functionality but had to be included for some of the
automated unit tests run by lgr.

## Installation

You can install lgr from CRAN

``` r
install.packages("lgr")
```

Or you can install the current development version directly from github

``` r
#install.packages("remotes")
remotes::install_github("s-fleck/lgr")
```

## Outlook

The long term goal is to support (nearly) all features of the python
logging module. If you have experience with python logging or Log4j and
are missing features/appenders that you’d like to see, please feel free
to post a feature request on the issue tracker.

## Acknowledgement

- [diagrams.net](https://app.diagrams.net/) for the flow chart in the
  vignette

repository: s-fleck/lgr

gha_language: HTML

gha_license_id: NOASSERTION

repo_name: s-fleck/lgr


text:
# Contract Playground

A fun way to play with contracts. To use, drag a person onto a contract, then pick your transaction to call.

To use:

    yarn install
    yarn run dev

repository: cipherzzz/origin-dollar

repo_name: cipherzzz/origin-dollar


text:
# Testing

Strapi's test suite is written using [mocha](https://mochajs.org/) and although
Strapi doesn't impose any testing framework for your apps, in this example we
will setup tests using the mocha framework.

## Setup

Before writing tests, you should setup a basic directory structure, like this:
```
./strapiApp
├── api/
├── ...
├── test/
│  ├── integration/
│  │  ├── controllers/
│  │  │  └── my_endpoint.test.js
│  │  ├── models/
│  │  │  └── my_model.test.js
│  │  └── ...
|  ├── ...
│  ├── bootstrap.js
```

## Boostrap

We are going to setup a `bootstrap.js` with `before` and `after` hooks to
perform any actions before and after our tests.
In this example, the app server is started before running any tests an stop
the server after tests are completed.

*./test/bootstrap.js*

```js
const strapi = require('strapi');

before(function (done) {
  strapi.start({}, function(err) {
    if (err) {
      return done(err);
    }

    done(err, strapi);
  });
});

after(function (done) {
  strapi.stop(done());
});
```

## Writing tests

Once you have setup your directory structure, you can start writing your tests.
In this example we use [co-supertest](https://github.com/avbel/co-supertest),
a `co` and `Supertest` integration library.
[Supertest](https://github.com/visionmedia/supertest) provides several useful
methods for testing HTTP requests.
If you want to test an api endpoint, you can do it like this:

*./test/integration/controllers/my_endpoint.js*

```js
const request = require('co-supertest');

describe('MyEndpoint Controller Integration', function() {
  describe('GET /my_endpoint', function() {
    it('should return 200 status code', function *() {
      yield request(strapi.config.url)
        .get('/my_endpoint')
        .expect(200)
        .expect('Content-Type', /json/)
        .end();
    });
  });
});
```

## Running tests

In order to run tests you can use `npm test`. In your `package.json`, in the
`scripts` section, add this:

*./package.json*

```js
"scripts": {
  "test": "mocha --require co-mocha test/bootstrap.js test/**/*.test.js"
}
```

Remember to run `test/bootstrap.js` before any other tests and, if you want,
use the `--require` option to pass any required dependencies you need available
in your tests.

repository: MunGell/strapi

repo_name: MunGell/strapi


text:
---
title: Building a Clojure project
layout: en

---

## What This Guide Covers

<aside markdown="block" class="ataglance">

| Clojure                                     | Default                                   |
|:--------------------------------------------|:------------------------------------------|
| [Default `install`](#dependency-management) | `lein deps`                             |
| [Default `script`](#default-build-script)   | `lein test`                               |
| [Matrix keys](#build-matrix)                | `env`, `lein`, `jdk`                      |
| Support                                     | [Travis<EMAIL_ADDRESS>|

Minimal example:

```yaml
language: clojure
```
{: data-file=".travis.yml"}

</aside>

{{ site.data.snippets.linux_note }}

This guide covers build environment and configuration topics specific to Clojure
projects. Please make sure to read our [Tutorial](/user/tutorial/)
and [general build configuration](/user/customizing-the-build/) guides first.

Clojure builds are not available on the macOS environment.

## CI Environment for Clojure Projects

Travis CI environment provides a large set of build tools for JVM languages with
[multiple JDKs, Ant, Gradle, Maven](/user/languages/java/#overview) and both
[Leiningen](http://leiningen.org) 1.7.x and 2.4.x (default).

## Dependency Management

If you use Leiningen, it will automatically install any dependencies that are
listed in the `project.clj` file.

### Alternate Install Step

If you need to install other dependencies before your tests can run, you should
set up the proper `:hooks` in `project.clj`.

If for some reason you can't use hooks,you can override the install step in your
`.travis.yml`:

```yaml
install: lein protobuf install
```
{: data-file=".travis.yml"}

See the [build configuration guide](/user/customizing-the-build/) to learn more.

## Build Script

### Using Midje

If your project uses [Midje](https://github.com/marick/Midje), make sure
[lein-midje](https://github.com/marick/Midje/wiki/Lein-midje) is on your
`project.clj` development dependencies list and override `script:` in
`.travis.yml` to run the Midje task:

```yaml
script: lein midje
```
{: data-file=".travis.yml"}

For Leiningen 1 add `:dev-dependencies` to `project.clj`:

```
:dev-dependencies [[midje "1.4.0"]
                   [lein-midje "1.0.10"]])
```
{: data-file=".project.clj"}

Leiningen 2 replaces `:dev-dependencies` with profiles:

```
:profiles {:dev {:dependencies [[midje "1.6.3"]]
                 :plugins [[lein-midje "3.0.0"]]}}
```
{: data-file=".project.clj"}

Please note that for projects that only support Clojure 1.3.0 and later
versions, you may need to exclude transient `org.clojure/clojure` for Midje in
project.clj:

```
:dev-dependencies [[midje "1.4.0" :exclusions [org.clojure/clojure]]
                   [lein-midje "1.0.10"]])
```
{: data-file=".project.clj"}

For real world example, see [Knockbox](https://github.com/reiddraper/knockbox).

### Using Speclj on Travis CI

If your project uses [Speclj](https://github.com/slagyr/speclj), make sure it is
listed in your development dependencies in `project.clj`, and include this
`script:` line in `.travis.yml`:

```yaml
script: lein spec
```
{: data-file=".travis.yml"}

For Leiningen 1, Speclj should be listed under `:dev-dependencies` in `project.clj`:

```
:dev-dependencies [[speclj "3.3.1"]]
```
{: data-file=".project.clj"}

Leiningen 2 replaces `:dev-dependencies` with profiles:

```
:profiles {:dev {:dependencies [[speclj "3.3.1"]]}}
```
{: data-file=".project.clj"}

## Using Leiningen 1

Leiningen 1 is provided side by side with 2.4.x. To use it, specify `lein` key in `.travis.yml`:

```yaml
lein: lein1
```
{: data-file=".travis.yml"}

In case you need to use `lein` binary in `before_script`, `install:`, `script:` commands and so on, use `lein1`:

```yaml
before_install:
  - lein1 bootstrap
```
{: data-file=".travis.yml"}

## Build Config Reference

You can find more information on the build config format for [Clojure](https://config.travis-ci.com/ref/language/clojure) in our [Travis CI Build Config Reference](https://config.travis-ci.com/).

Task chaining requires using the `do` task:

```yaml
script: lein1 do javac, test
```
{: data-file=".travis.yml"}

## Testing Against Multiple JDKs

As for any JVM language, it is also possible to [test against multiple JDKs](/user/languages/java/#testing-against-multiple-jdks).

### Examples

- [Monger](https://github.com/michaelklishin/monger/blob/master/.travis.yml)
- [Welle](https://github.com/michaelklishin/welle/blob/master/.travis.yml)
- [Langohr](https://github.com/michaelklishin/langohr/blob/master/.travis.yml)
- [Neocons](https://github.com/michaelklishin/neocons/blob/master/.travis.yml)

## Testing Against Multiple Versions of Clojure

### With Leiningen 1

Leiningen has an excellent plugin called [lein-multi](https://github.com/maravillas/lein-multi) that lets you effortlessly test against multiple versions of
Clojure (for example, 1.3, 1.4 and alphas/betas/snapshots of the most recent development version). Because leiningen can run tests against any version of Clojure (not necessary the same version as Leiningen itself uses),
there is no need for runtime switchers (like RVM) for Clojure.

To use lein-multi on Travis CI, add it to `:plugins` in project.clj (note, this feature is only available starting with Leiningen 1.7.0) and
override `script:` to run `lein multi test` instead of default `lein test`:

```yaml
language: clojure
script: lein1 multi test
```
{: data-file=".travis.yml"}

For a real world example, see [Monger](https://github.com/michaelklishin/monger).

### With Leiningen 2

Leiningen 2 has a core feature that replaces `lein-multi`: [Profiles](https://github.com/technomancy/leiningen/blob/master/doc/TUTORIAL.md). To run your tests against
multiple profiles (and thus, multiple dependency sets or Clojure versions), use `lein with-profile` command like so:

```yaml
lein: lein
script: lein with-profile dev:1.4 test
```
{: data-file=".travis.yml"}

where `dev:1.4` is a colon-separated list of profiles to run `test` task against. Use `lein profiles` to list your project's profiles
and `lein help with-profile` to learn more about the `with-profiles` task.

#### Using a more recent versions of Leiningen

If your Clojure project requires a more recent version of Leiningen, you can specify it with:

```yaml
language: clojure

lein: 2.6.1 # version 2 and up
```
{: data-file=".travis.yml"}

The job will install the specified version of Leiningen if it is not pre-installed,
and move on to install your project's dependencies.

### Example

For a real world example, see [Neocons](https://github.com/michaelklishin/neocons).

## Examples

- [monger's .travis.yml](https://github.com/michaelklishin/monger/blob/master/.travis.yml)
- [welle's .travis.yml](https://github.com/michaelklishin/welle/blob/master/.travis.yml)
- [langohr's .travis.yml](https://github.com/michaelklishin/langohr/blob/master/.travis.yml)
- [neocons' .travis.yml](https://github.com/michaelklishin/neocons/blob/master/.travis.yml)
- [Knockbox's .travis.yml](https://github.com/reiddraper/knockbox/blob/master/.travis.yml)
- [Sumo's .travis.yml](https://github.com/reiddraper/sumo/blob/master/.travis.yml)

gha_language: CSS


text:
# ChgkRating

[![Gem Version](https://badge.fury.io/rb/chgk_rating.svg)](https://badge.fury.io/rb/chgk_rating)
![CI](https://github.com/bodrovis/ChgkRating/actions/workflows/ci.yml/badge.svg)
[![Test Coverage](https://codecov.io/gh/bodrovis/ChgkRating/graph/badge.svg)](https://codecov.io/gh/bodrovis/ChgkRating)

**This gem is in passive maintenance mode. I won't release any new features or introduce any complex enhancements as ChgkRating v1 is deprecated. Please use [rating-chgk-v2 gem](https://github.com/bodrovis/rating-chgk-v2) which works with the new version of the API.**

Ruby interface for the [rating.chgk.info](http://rating.chgk.info/index.php/api) WebAPI. This is not just a wrapper, but rather a quite complex opinionated client that allows to easily work with various API resources.

[Competitive CHGK (aka "What? Where? When?")](https://en.wikipedia.org/wiki/What%3F_Where%3F_When%3F#Competitive_game) is a popular intellectual game where teams of up to six people are trying to find an answers to various questions.

The main documentation can be found at the [official website](http://chgk-rating.bodrovis.tech/).

Документация на русском языке также доступна на [официальном сайте](http://chgk-rating.bodrovis.tech/index_ru).

Documentation can also be found on [RubyDoc](http://www.rubydoc.info/github/bodrovis/ChgkRating/master).

## Installation and Requirements

This gem works **only** with Ruby 2.4+ and I have no plans of making it compatible with older versions. Apart from that, it has no special requirements.

Install it by running:

    $ gem install chgk_rating

## A Very Quick Example

```ruby
# Instantiate the client:
client = ChgkRating.client

# Get all players:
client.players

# Get a specific team:
team = client.team 1

# Get information about the team at a given tournament:
team.at_tournament 1000

# Get results for the given team as the tournament:
team.at_tournament(1000).results

# The same data can be fetched with:
client.team_results_at_tournament 1000, team

# Or you can even grab the tournament and pass it later:
tournament = client.tournament 1000

team.at_tournament(tournament).results
# OR
client.team_results_at_tournament tournament, team
```

## Testing

Tests run against mock responses so you don't need to perform any special setup. Simply pull the code and run:

    $ bundle install
    $ rspec .

## License

This plugin is licensed under the [MIT License](https://github.com/bodrovis/ChgkRating/blob/master/LICENSE).

Copyright (c) [Ilya Krukowski](http://bodrovis.tech)

repository: bodrovis/ChgkRating

gha_language: Ruby

repo_name: bodrovis/ChgkRating


text:
# Contributing to Liberty Ant tasks

We welcome contributions but request that you follow [these guidelines](https://github.com/WASdev/wasdev.github.io/blob/master/CONTRIBUTING.md).

[Issue tracker][].

[issue tracker]: https://github.com/WASdev/ci.ant/issues

gha_language: Java


text:
---
layout: page
title: "Configure"
meta: "false"
tags: ["ops", "devops"]
---

The configuration step in the DevOps toolchain will be covered.  Also including any core infrastructure links in this page.

## [Kubernetes/Container](/info/k8s)

Kubernetes(k8s) is the best modern approach for deploying and maintaining code.

## Infrastructure As Code

- [CrossPlane](https://crossplane.io/): Infrastructure provider as k8s resources
  - [Is Crossplane the Infrastructure LLVM?](https://danielmangum.com/posts/crossplane-infrastructure-llvm/)
- [Terraform](https://github.com/hashicorp/terraform): A very popular IaC platform
  - [tf-free](https://github.com/gruberdev/tf-free): Provision free-tier resources across a variety of cloud providers.
  - [Infracost](https://www.infracost.io/): Terraform Infrastructure Cost estimation, which can be baked into a CD pipeline for better review of what infrastructure costs will be.
  - [Terraservice](https://www.contino.io/insights/a-model-for-scaling-terraform-workflows-in-a-large-complex-organization): A model for services in Terraform
  - [Terracognita](https://github.com/cycloidio/terracognita): Generate IaC from existing code.
  - [Terraformer](https://github.com/GoogleCloudPlatform/terraformer): Produce terraform from existing resources.
  - [Testing Terraform with pytest](https://betterprogramming.pub/terraform-resource-testing-101-c9da424faaf3) - an Interesting concept to directly test against the Terraform state file, versus something like [Terratest](https://terratest.gruntwork.io/) that actually builds out infrastructure.
- Cloud Instance Cost
  - [AWS: Vantage Instance Cost](https://instances.vantage.sh/): Used to be EC2Instances.info, but Vantage is now hosting. [Source is still on Github](https://github.com/vantage-sh/ec2instances.info)
  - [Azure: Azureprice.net](https://azureprice.net/)
  Great info.  Unfortunately source is not available.

## Amazon Web Services (AWS)

- [AWS NAT Gateway Alternative #1 - AlterNAT](https://github.com/1debit/alternat): Redundant, but self managed (although Terraform and Lambdas cover most use-cases)
- [AWS NAT Gateway Alternative #2 - fck-nat](https://github.com/AndrewGuenther/fck-nat): Simplier solution

## System Build Tool

- [Packer](https://www.packer.io/): Designed to quickly deploy test virtual machines in a specific configuration.  Can pull in external configuration management such as Ansible if desired.
- [ClusterAPI](https://cluster-api.sigs.k8s.io/): Kubernetes focused provisioning.
- [Tinkerbell](https://tinkerbell.org/): Provision and Manange Bare Metal Anywhere

## Configuration Management

Configuration Management: Generally an anti-pattern.  Much prefer leveraging Packer to build immutable images, and Terraform or Crossplane to deploy

- Ansible:
  - [Ansible](https://github.com/ansible/ansible): Ansible core project
  - [AnsiJet](https://github.com/hiddentao/ansijet): Ansible playbook automation server.  Provides a REST API and playbook results storage in MongoDB.
- [Jenkins](https://jenkins-ci.org/): Generally used for CI on code, could be integrated with the above to perform
full integration testing on a stack

## DNS

- [IpIFY](https://www.ipify.org/): Light-weight API to get your public IP address.  Basic IP info is free to use.  Can register to get GeoIP Information.
- [ip-api.com](https://ip-api.com/).  Provids IP, geo-location and ISP information at `http://ip-api.com/json`  Free for non-commercial purposes.
- [NoIP](https://nip.io/) and [XIP](http://xip.io/): Automatic DNS based on IP address


text:
---
template: blog-post.jade
title: Another Overdue Update
date: '2011-12-04T23:21:09-05:00'
tags:
- personal
- gym
- health
- programming
tumblr_url: http://blog.baf.cc/post/13766111681/another-overdue-update
---
I've been doing a horrible job at blogging, as usual. I've gotten a head start on what would have (yet again) been a New Year's resolution - going to the gym. I started going to a local gym with a friend - which is great, it gives somebody to work out with, somebody to be accountable to, etc. So I figured why not get started on what would likely end up being another New Year's resolution - blogging more.

I'd like to attempt to write a blog post every night. That probably won't happen, but it's something to shoot for. Anything at least semi-regular would be nice. Anything goes here, programming, personal stuff, workouts, etc.

As far as the gym - my main goal is to lose some weight and get into shape. Bulking up a little bit is a secondary goal, but nothing I'm going to actively seek at the moment. I seem to have settled in around 200 pounds lately, and I wouldn't mind dropping at least 50 of it (or less, depending on how much muscle I build, being that muscle weighs more than fat).

Wooters.us desperately needs some attention. This seems to be a recurring, tragic issue. It's just hard to find the time to do it - I have so many other things I want to do as well.

And, on a closing note, I think I'm going to host a programming competition this month. I need to get in gear, and set up a site and everything for it, but I'm hoping for moderate success. There seems to be a [void over at allegro.cc](http://www.allegro.cc/forums/thread/608970) these days with Jakub gone, with nobody left to host ChristmasHack. So I'm planning on organizing ‘SantaHack' to fill this void. More on that as it comes.


text:
This Procure To Pay dataset shows end-to-end P2P process built from four common SAP processes: Purchase Requisition, Purchase Order, Invoice, Good Receipt.
It demonstrates nicely how powerful the multi-level process capability of IBM Process Mining is. You will see that we are possibly using four process_id columns in the dataset, each column correspond to the ID of one of the four SAP processes involved in this end-to-end business process.
For example, when 3 goods are purchased in a single order, we keep seeing a single process.

Steps:
1. Download this ZIP and unzip:
1. Create a Process Mining project
1. Upload the data set from the Datasource tab: "p2p_automotive_As_Is.zip"
1. Upload the project backup "P2P - Automotive_2020-10-23_071252.idp" (see below how). The project backup does the mapping automatically, and load the P2P dashboards, KPIs, costs...
1. Visualize the process

Note: IBM can provide a Talend-based ETL project to produce this dataset from your own SAP system upon request, as an accelerator (contribution). Contact<EMAIL_ADDRESS>
## P2P Generated Model

## P2P Conformance Checking
![](./Images/P2PConformanceChecking.png?sanitize=true)

## Order Maverick
Among P2P sources of waste, and one of the more difficult to find and fix is “Maverick” buying, i.e. the expense resulting from purchases that are breaking the rules established by corporate procedures.
![](./Images/OrderMaverick.png?sanitize=true)

## Spent Under Management
Spend Under Management measures the percentage of total spend that falls into the procurement department responsibility.
![](./Images/SpentUnderManagement.png?sanitize=true)

repository: huihuid/processmining

repo_name: huihuid/processmining


text:
---
title: Foundation - Real-time Customer Profile - Create a segment - UI
description: Foundation - Real-time Customer Profile - Create a segment - UI
kt: 5342
audience: Data Engineer, Data Architect, Marketer
doc-type: tutorial
activity:
---

# Exercise 4 - Create a segment - UI

In this exercise, you'll create a segment by making use of Adobe Experience Platform's Segment Builder.

## Story

In the Real-time Customer Profile, all profile data is shown alongside event data and existing segment memberships. The data that is shown  can come from anywhere, from Adobe applications and external solutions. This is the most powerful view in Adobe Experience Platform—the experience system of record.

Log into [Adobe Experience Platform](https://experience.adobe.com/platform)

After logging in, you'll land on the homepage of Adobe Experience Platform.

![Data Ingestion](./images/home.png)

Before you continue, make sure you are in the **Production Prod** environment in the blue line on top of your screen.

In the menu on the left side, go to **Segments**.

![Segmentation](./images/menuseg.png)

On this page, you can see an overview of all existing segments.

![Segmentation](./images/segmentation.png)

Click on the **Create segment** button to start creating a new segment.

![Segmentation](./images/createnewsegment.png)

Once you're in the new segment builder, you immediately notice the **Attributes** menu option and the **XDM Individual Profile** reference.

![Segmentation](./images/segmentationui.png)

Since XDM is the language that powers the experience business, XDM is also the foundation for the segment builder. All data that is ingested in Platform should be mapped against XDM, and as such, all data becomes part of the same data model regardless of where that data comes from. This gives you a big advantage when building segments, as from this one segment builder UI, you can combine data from any origin in the same workflow. Segments built within Segment Builder can be sent to solutions like Adobe Target, Adobe Campaign and Adobe Audience Manager for activation.

Let's build a segment which includes all **male** customers.

To get to the gender attribute, you need to understand and know XDM.

Gender is an attribute of Person, which can be found under Attributes. So to get there, you'll start by clicking on **XDM Individual Profile**.

![Segmentation](./images/person.png)

From the **XDM Individual Profile** window, select **Person**.

![Segmentation](./images/gender.png)

And in **Person**, you can find the **Gender** attribute. Drag the Gender attribute onto the segment builder.

Now you can choose the specific gender out of the pre-populated options. In this case, let's pick **Male**.

![Segmentation](./images/genderselection.png)

After selecting **Male**, you can get an estimation of the segment's population by pushing the **Refresh Estimate** button. This is very helpful for a business user, so that they can see the impact of certain attributes on the resulting segment size.

![Segmentation](./images/segmentpreview.png)

Next, we should refine our segment a bit. I'd like to build a segment out of all male customers that have viewed the product **Proteus Fitness Jackshirt (Orange)**.

To build out this segment, you need to add an Experience Event. You can find all Experience Events by clicking on the **Events** icon in the **Segments** menu bar.

![Segmentation](./images/findee.png)

Next, you'll see the top-level, **ExperienceEvents** node.

![Segmentation](./images/see.png)

To find customers that have visited the **Proteus Fitness Jackshirt (Orange)** product, click on **XDM ExperienceEvent**.

![Segmentation](./images/comm_pv.png)

Go to **Product List Items**.

![Segmentation](./images/eeweb.png)

Select **Name** and drag and drop the **Name** object from the left menu onto the segment builder canvas into the **Events** section.

![Segmentation](./images/eewebpdtlname.png)

The comparison parameter should be **equals** and in the input field, enter **Proteus Fitness Jackshirt (Orange)**.

![Segmentation](./images/pv.png)

Every time you add an element to the segment builder, you can click the **Refresh Estimate** button to get a new estimate of the population in your segment.

So far, we've only used the UI to build our segment, but there's also a code-option to build a segment.

When building a segment, we're actually composing a Profile Query Language (PQL) query. To visualize the PQL code, you can click on the **Code View** switcher in the upper right corner of the segment builder.

![Segmentation](./images/codeview.png)

Now you can see the full PQL statement:

```sql
person.gender in ["male"] and (select _Any1 from xEvent, _Any1__Product_list_items1 from _Any1.productListItems where _Any1__Product_list_items1.name.equals("Proteus Fitness Jackshirt (Orange)", false))
```

You can also preview a sample of the customer profiles that are part of this segment, by clicking on **View Profiles**.

![Segmentation](./images/previewprofiles.png)

![Segmentation](./images/previewprofilesdtl.png)

Finally, let's give your segment a name and save it.

As a naming convention, we'll use:

* `all - Male customers with interest in Proteus Fitness Jackshirt (Orange) - ldap`

Please replace **ldap** with your ldap.

![Segmentation](./images/segmentname.png)

It's also important to note the **Streaming** toggle.

![Segmentation](./images/streaming.png)

By enabling the **Streaming** toggle, your segment will qualify in real-time (as soon as the data is available in Adobe Experience Platform, data collection using Web SDK is a requirement for this) and will be available for activation in real-time.

Then, click the **Save** button to save your segment, after which you'll be taken back to the Segment overview  page.

![Segmentation](./images/savedsegment.png)

Let's now continue to the next exercise and build a segment through the API.

Next Step: [3.5 Create a segment - API](./ex5.md)

[Go Back to Module 3](./real-time-customer-profile.md)

[Go Back to All Modules](../../overview.md)


text:
# Scala.js typings for microsoft__fetch-event-source

Typings are for version 2.0.1

## Library description:
A better API for making Event Source requests, with all the features of fetch()

|                    |                 |
| ------------------ | :-------------: |
| Full name          | @microsoft/fetch-event-source |
| Keywords           | - |
| # releases         | 9 |
| # dependents       | 0.0 |
| # downloads        | 3667955.3333333335 |
| # stars            | 94.0 |

## Links
- [Homepage](https://github.com/Azure/fetch-event-source#readme)
- [Bugs](https://github.com/Azure/fetch-event-source/issues)
- [Repository](https://github.com/Azure/fetch-event-source)
- [Npm](https://www.npmjs.com/package/%40microsoft%2Ffetch-event-source)

## Note
This library has been generated from typescript code from first party type definitions.

Provided with :purple_heart: from [ScalablyTyped](https://github.com/oyvindberg/ScalablyTyped)

## Usage
See [the main readme](../../readme.md) for instructions.

repository: ScalablyTyped/Distribution

repo_name: ScalablyTyped/Distribution


text:
Meet Nolan Kay Bushnell: one of the founder fathers of video games industry who raised it to the new level.

---
Bushnell worked at Lagoon Amusement Park for many years while attending college (once he loose all his money in poker game so had to work to pay for the college).

He liked the concept of getting people curious about the game and from there getting them to pay the fee in order to play.

---
In the late 1960s, Nolan Bushnell saw Spacewar! running on a mainframe at the University of Utah where he was a student.
Bushnell worked during the summer at Lagoon Amusement Park in Utah as a manager of the games department overseeing the arcade games,
and when he saw **Spacewar!** he believed that an arcade game version of the game would be very popular.

---
The high price of computers capable of running the game, however, meant that any such arcade game would not be economically feasible.

---
Soon after, he saw an ad for the Data General Nova computer, which cost only US$4,000 (equivalent to about $25,000 in 2019),
and thought again about his Spacewar arcade game idea; he believed that at that price, if he were able to connect four monitors
and coin slots to allow multiple games to run simultaneously, the game would be economically viable.

---
# Data General Nova computer

---
Bushnell and his mate began to design custom hardware to run the game's functions, and they soon discovered that the cost
to build the whole game's computing systems would be much lower.

On the other hand, however, the custom hardware was not as powerful
as the more expensive Nova computer, which meant that the pair needed to make gameplay modifications.

---
# Computer space

---
Spacewar was a two-player game featuring dogfights around the gravitational field of a central star; neither of these features
could be run on the dedicated circuits the pair were making, so the game was cut down to a single-player game wherein the player would fight
against two computer-controlled spaceships in open space.

---
By January 1971, the pair had built some basic hardware which could connect to a monitor, with plans to continue expanding it
to make a game now named Cosmic Combat, but they were still far away from turning what was then a dot moving on a screen into a full Spacewar-like game cabinet.

---
In January 1971, Bushnell and Dabney founded Syzygy Engineering as an official company.
They approached Ampex and a prior manager of Dabney's with their prototype, but found no interest.

---
During a dentist appointment in early 1971, Bushnell told the dentist about the game and that he was looking for a manufacturer; the dentist in turn referred him to another patient of his, Dave Ralstin, the sales manager for Nutting Associates in Mountain View, California.
Nutting had been founded in 1967 on the basis of [Computer Quiz](https://gameorigo.com/computer-quiz-arcade-1967), an analog quiz arcade game, and by 1971 was looking for another hit game.

---
# Computer Quiz game

---
After meeting with Bushnell, Nutting felt that his game was the potential success they needed to replace falling sales of Computer Quiz updates, as they had not had a hit game since.
Nutting not only agreed to manufacture the game but also hired Bushnell as their chief engineer, as they had no real engineering team at the time. Furthermore, Syzygy Engineering retained ownership of the game, even though Nutting agreed to give Syzygy space to build the prototype and to manufacture the game once complete.

---
> _Computer Space_ is a space combat arcade game developed in 1971 as one of the last games created in the early history of video games.
> Computer Space is a derivative of the 1962 computer game Spacewar!, possibly the first video game to spread to multiple computer installations.

---
The game is enclosed in a custom fiberglass cabinet in one of four colors, which Bushnell designed himself to be futuristic.

---
# Reception
Nutting ordered an initial production run of 1,500 units of Computer Space, an optimistic decision given that a hit arcade game
at the time would sell around 2,000 units, though a handful had reached 10,000.

---
Reception to the game from distributors was mixed; while some were excited by the game, others felt it to be confusing
and would amount to nothing more than a passing fad at best.
By spring 1972 the game had sold over 1,000 units, and according to Bushnell in 1976 ended up selling between 1,300 and 1,500 units.

---
While this was a commercial success, making over US$1,000,000 (equivalent to about $6,112,000 in 2019),
it was a disappointment to Nutting, who had been hoping for a large-scale success like Computer Quiz.

---
# Computer space game ads poster

---
The game's relative lack of success was attributed to the complexity of its controls and a steep learning curve,
which pushed away customers used to less complex games.

---
Bushnell noted that the locations that the game did well in,
like the Dutch Goose playtest location, were generally located near university campuses;
the general market for coin-operated games, however, was in working-class bars, where the patrons were less interested in deciphering a complicated game.

---
In the documentary Video Game Invasion: The History of a Global Obsession, Bushnell explained,
"Sure, I loved it, and all my friends loved it, but all my friends were engineers. It was a little too complicated for the guy with the beer in the bar."

---
Bushnell has also stated that part of the difficulty lay in the novelty of the game; he has said that even a few years later
the controls and gameplay would have been more understandable to players who would have seen other video games by then.

---
Conversely, Bushnell and Dabney have said that the game's novelty was also part of its appeal to players—most people had never seen
a television screen displaying images being controlled by a person in front of it, rather than playing video from a remote television station.


text:
### Weighted Alternating Least Squares (WALS)

Go back to the [[AI Glossary]]

#recsystems

An algorithm for minimizing the objective function during matrix factorization in recommendation systems, which allows a downweighting of the missing examples. WALS minimizes the weighted squared error between the original matrix and the reconstruction by alternating between fixing the row factorization and column factorization. Each of these optimizations can be solved by least squares convex optimization. For details, see the Recommendation Systems course

url: https://raw.githubusercontent.com/KGBicheno/KGB_Agora/70ea95c9d38ab2f31abbd510691bb4c050a6cb3b/Artificial Intelligence/Introduction to AI/Week 3 - Introduction/Definitions/Weighted_Alternating_Least_Squares_(Wals).md


text:
---
  title: Creating vSphere VM's using Ansible
---

I am putting this out here in case anyone else may be interested in
spinning up some VM's using Ansible. I am doing this with Ansible 1.8.4
and connecting to vCenter 6.0 GA. I will be adding to this post as I add
more functionality. Currently with Ansible 1.8.4 you cannot spin up
VM's using templates but that is added in 1.9 which is currently only
available from GitHub in the dev branch. Not what I want to use for this
right now as I like to use products that are release versions for
stability and consistency. :) What I will be doing in this post is
spinning up 8 VM's ( 3 CentOS DB and 5 Ubuntu64 Web). Once they are
spun up you will need to install the OS on them (for now).

We first need to create an inventory list of the servers along with some
variables to be passed to our Ansible playbook which will create the
VM's for us. You could easily run this from Jenkins if you want a webUI
driven way to do this as well ( more on this later ).

Let's create our inventory list which in this example I will be calling
create_vms_hosts.

```bash
nano create_vms_hosts
```

Now copy and paste the following or create your own

```bash
[web-vms]
ans-web[01:05] disk='10' datastore='SSD-Pool_ELKStack_dev (NAS01)' network='vSS-OpenStack_Default' memory='256' cpucount='1' osid='ubuntu64Guest'

[db-vms]

ans-db[01:03] disk='20' datastore='SSD-Pool_ELKStack_dev (NAS01)' network='vSS-OpenStack_Default' memory='1024' cpucount='2' osid='rhel6_64Guest'
```

What we are specifying here is the group names (web-vms and db-vms) to
specify different variables for each group of servers to build. I will
breakdown each variable below to put some meaning to them.
`ans-web[01:05]` and `ans-db[01:03]` ---- These are the actual VM
names that we will be creating. Ansible has the ability to use regex
type values to represent a group of items...in this case VM names...So
Ansible will be creating ans-web01 - answeb05 and ans-db01 - ans-db03
for us.

disk= --- is the size in GB to create for each VM
datastore= --- name of the datastore to create the VMs on
network= --- name of network (portgroup) to place the VMs on
memory= --- the amount of memory in MB to allocate to the VMs
cpucount= --- the number of vCPU's to allocate to the VMs
osid= --- the OS Identifier to specify for the OS type.... reference
[this](https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html "https\://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html")
guide for OSID's

Now we need to create the actual ansible playbook to run to create the
VMs for us. In this case I will be calling it create_vms.yml

```bash
nano create_vms.yml
```

Now copy and paste the below and modify to suit your requirements.

{% raw %}

```yaml
---
- hosts: all
  gather_facts: false
  connection: local
  user: remote
  sudo: true

  vars_prompt:
    - name: "vcenter_hostname"
      prompt: "Enter vcenter hostname"
      private: no
      default: "vcsa"
    - name: "vcenter_user"
      prompt: "Enter vcenter username"
      private: no
    - name: "vcenter_pass"
      prompt: "Enter vcenter password"
      private: yes

  vars:
    datacenter: 'everythingshouldbevirtual'
    esxi_host: 'esxi01.everythingshouldbevirtual.local'
    notes: 'Created by Ansible'

  tasks:
    - vsphere_guest:
        vcenter_hostname: "{{ vcenter_hostname }}"
        username: "{{ vcenter_user }}"
        password: "{{ vcenter_pass }}"
        guest: "{{ inventory_hostname }}"
        state: present
        vm_extra_config:
          notes: "{{ notes }}"
        vm_disk:
          disk1:
            size_gb: "{{ disk }}"
            type: thin
            datastore: "{{ datastore }}"
        vm_nic:
          nic1:
            type: vmxnet3
            network: "{{ network }}"
            network_type: standard
        vm_hardware:
          memory_mb: "{{ memory }}"
          num_cpus: "{{ cpucount }}"
          osid: "{{ osid }}"
          scsi: paravirtual
        esxi:
          datacenter: "{{ datacenter }}"
          hostname: "{{ esxi_host }}"
```

{% endraw %}

This method will prompt for the vCenter hostname to connect to, username
and password to connect to vCenter. You will want to modify the section
under vars: to meet your specific requirements and naming of datacenter
and esxi_host. The esxi_host is just a placeholder to initially create
your VMs.

So with this all setup you will need to do one more thing before running
this playbook and that is installing the python module for vSphere.

```bash
sudo pip install pysphere
```

Once this is installed you are now ready to run your playbook.

```bash
ansible-playbook -i create_vms_hosts create_vms.yml
```

![Screen Shot 2015-03-25 at 4.36.53 PM](../../assets/Screen-Shot-2015-03-25-at-4.36.53-PM-300x59.png)

![Screen Shot 2015-03-25 at 4.37.28 PM](../../assets/Screen-Shot-2015-03-25-at-4.37.28-PM-300x178.png)

![Screen Shot 2015-03-25 at 4.37.36 PM](../../assets/Screen-Shot-2015-03-25-at-4.37.36-PM-300x218.png)

And there you have it...You have now successfully created some VMs
using Ansible :)

**_Updated!!! 01/13/2015_**

Here is a newer updated playbook to create VMs.

{% raw %}

```yaml
---
- name: create some vms
  hosts: localhost
  connection: local
  vars_prompt:
    - name: "vcenter_host"
      prompt: "Enter vcenter host"
      private: no
      default: "vcsa"
    - name: "vcenter_user"
      prompt: "Enter vcenter username"
      private: no
    - name: "vcenter_pass"
      prompt: "Enter vcenter password"
      private: yes
  vars:
    esxi_host: 'esxi01.{{ pri_domain_name }}'
    vcenter_datacenter: 'LAB'
    vcenter_datastore: 'Tier-3 (NAS01)'
    vcenter_folder: 'ansible-builds'
    vms:
      - guest: 'test01'
        state: 'powered_on'
        vcpu_hotadd: 'no'
        mem_hotadd: 'no'
        notes: 'Ansible Created'
        num_disks: 1
        disks:
          disk1:
            size: 10
            type: 'thin'
        network: 'vSS-Green-Servers-VLAN101'
        memory: 1024
        cpus: 1
        osid: 'ubuntu64Guest'
      - guest: 'test02'
        state: 'powered_on'
        vcpu_hotadd: 'no'
        mem_hotadd: 'no'
        notes: 'Ansible Created'
        num_disks: 2
        disks:
          disk1:
            size: 10
            type: 'thin'
          disk2:
            size: 20
            type: 'thin'
        network: 'vSS-Green-Servers-VLAN101'
        memory: 1024
        cpus: 1
        osid: 'ubuntu64Guest'
      - guest: 'test03'
        state: 'powered_on'
        vcpu_hotadd: 'no'
        mem_hotadd: 'no'
        notes: 'Ansible Created'
        num_disks: 3
        disks:
          disk1:
            size: 10
            type: 'thin'
          disk2:
            size: 20
            type: 'thin'
          disk3:
            size: 30
            type: 'thin'
        network: 'vSS-Green-Servers-VLAN101'
        memory: 1024
        cpus: 1
        osid: 'ubuntu64Guest'
    pri_domain_name: 'everythingshouldbevirtual.local'
  tasks:
    - name: create vms (Single Disk)
      vsphere_guest:
        vcenter_hostname: "{{ vcenter_host }}"
        username: "{{ vcenter_user }}"
        password: "{{ vcenter_pass }}"
        guest: "{{ item['guest'] }}"
        state: "{{ item['state'] }}"
        vm_extra_config:
          vcpu.hotadd: "{{ item['vcpu_hotadd']|default(omit) }}"
          mem.hotadd: "{{ item['mem_hotadd']|default(omit) }}"
          notes: "{{ item['notes']|default(omit) }}"
          folder: "{{ vcenter_folder }}"
        vm_disk:
          disk1:
            size_gb: "{{ item['disks']['disk1']['size'] }}"
            type: "{{ item['disks']['disk1']['type'] }}"
            datastore: "{{ vcenter_datastore }}"
            folder: "{{ vcenter_folder }}"
        vm_nic:
          nic1:
            type: "vmxnet3"
            network: "{{ item['network'] }}"
            network_type: "standard"
        vm_hardware:
          memory_mb: "{{ item['memory'] }}"
          num_cpus: "{{ item['cpus'] }}"
          osid: "{{ item['osid'] }}"
          scsi: "paravirtual"
        esxi:
          datacenter: "{{ vcenter_datacenter }}"
          hostname: "{{ esxi_host }}"
      with_items: vms
      when: item['num_disks'] == 1

    - name: create vms (Multi Disk - 2 Disks)
      vsphere_guest:
        vcenter_hostname: "{{ vcenter_host }}"
        username: "{{ vcenter_user }}"
        password: "{{ vcenter_pass }}"
        guest: "{{ item['guest'] }}"
        state: "{{ item['state'] }}"
        vm_extra_config:
          vcpu.hotadd: "{{ item['vcpu_hotadd']|default(omit) }}"
          mem.hotadd: "{{ item['mem_hotadd']|default(omit) }}"
          notes: "{{ item['notes']|default(omit) }}"
          folder: "{{ vcenter_folder }}"
        vm_disk:
          disk1:
            size_gb: "{{ item['disks']['disk1']['size'] }}"
            type: "{{ item['disks']['disk1']['type'] }}"
            datastore: "{{ vcenter_datastore }}"
            folder: "{{ vcenter_folder }}"
          disk2:
            size_gb: "{{ item['disks']['disk2']['size'] }}"
            type: "{{ item['disks']['disk2']['type'] }}"
            datastore: "{{ vcenter_datastore }}"
            folder: "{{ vcenter_folder }}"
        vm_nic:
          nic1:
            type: "vmxnet3"
            network: "{{ item['network'] }}"
            network_type: "standard"
        vm_hardware:
          memory_mb: "{{ item['memory'] }}"
          num_cpus: "{{ item['cpus'] }}"
          osid: "{{ item['osid'] }}"
          scsi: "paravirtual"
        esxi:
          datacenter: "{{ vcenter_datacenter }}"
          hostname: "{{ esxi_host }}"
      with_items: vms
      when: item['num_disks'] == 2

    - name: create vms (Multi Disk - 3 DIsks)
      vsphere_guest:
        vcenter_hostname: "{{ vcenter_host }}"
        username: "{{ vcenter_user }}"
        password: "{{ vcenter_pass }}"
        guest: "{{ item['guest'] }}"
        state: "{{ item['state'] }}"
        vm_extra_config:
          vcpu.hotadd: "{{ item['vcpu_hotadd']|default(omit) }}"
          mem.hotadd: "{{ item['mem_hotadd']|default(omit) }}"
          notes: "{{ item['notes']|default(omit) }}"
          folder: "{{ vcenter_folder }}"
        vm_disk:
          disk1:
            size_gb: "{{ item['disks']['disk1']['size'] }}"
            type: "{{ item['disks']['disk1']['type'] }}"
            datastore: "{{ vcenter_datastore }}"
            folder: "{{ vcenter_folder }}"
          disk2:
            size_gb: "{{ item['disks']['disk2']['size'] }}"
            type: "{{ item['disks']['disk2']['type'] }}"
            datastore: "{{ vcenter_datastore }}"
            folder: "{{ vcenter_folder }}"
          disk3:
            size_gb: "{{ item['disks']['disk3']['size'] }}"
            type: "{{ item['disks']['disk3']['type'] }}"
            datastore: "{{ vcenter_datastore }}"
            folder: "{{ vcenter_folder }}"
        vm_nic:
          nic1:
            type: "vmxnet3"
            network: "{{ item['network'] }}"
            network_type: "standard"
        vm_hardware:
          memory_mb: "{{ item['memory'] }}"
          num_cpus: "{{ item['cpus'] }}"
          osid: "{{ item['osid'] }}"
          scsi: "paravirtual"
        esxi:
          datacenter: "{{ vcenter_datacenter }}"
          hostname: "{{ esxi_host }}"
      with_items: vms
      when: item['num_disks'] == 3
```

{% endraw %}

Enjoy!

branch_name: refs/heads/gh-pages


text:
# nomnomd = nomnoml + md

**nomnomd** processes Markdown with included or referenced [nomnoml] diagrams and produces HTML.

I threw together **nomnomd** to write documentation for a project where I wanted to keep all docs in the code repo and depend on as few external tools as possible.

Each generated HTML file is self-contained.

## Markdown extensions

### Embedded [nomnoml] diagrams

By using the `nomnoml` fence code, a diagram can be written directly in a code block:

~~~markdown
```nomnoml
[A] -> [B]
```
~~~

**nomnoml** files (ending in `.noml` or `.nomnoml`) can be referenced as images:

```markdown
![Class Diagram](./classes.noml)
```

In both cases, the generated SVG is embedded in the resulting HTML file.
The generated HTML adds a CSS-based zoom function, to view detailed diagrams up close.

### Markdown file links, listings and includes

You can link to other Markdown files:

```markdown
[A link][linked.md]
```

**nomnomd** overloads the Markdown image syntax to mean "in place" or "here".
This allows for creating file lists

```markdown
![](./docs)
```

and including files:

```markdown
![Changelist](changelist.md)
```

Note that only Markdown (.md) files are listed and included.

List entries can be decorated by entering a [pupa] template as `alt` text, like this:

```markdown
![- {title}](./docs)
```

The template will use data from the JSON frontmatter of each listed file.

### Emojis

All [GitHub emojis](https://github.com/ikatyang/emoji-cheat-sheet/blob/master/README.md) should work. :white_check_mark:

## Themes

[sheetleeten] theme files can be used to override the default theme:

```shell
$ npx @erkkah/nomnomd --theme coffee.css docs.md
```

Creating themes is easy, basically just setting four colors and two fonts.

Syntax highlighting is provided by [highlight.js]. The default theme can be changed by specifying a theme name:

```shell
$ npx @erkkah/nomnomd --hltheme rainbow docs.md
```

## Working with **nomnomd**

```
Usage:
    nomnomd [options] <files...>

    Options:
        [--help]
        [--out DIR]
        [--theme FILE]
        [--hltheme <hljs-theme>]
        [--serve <port>]
        [--recursive|-r]
```

Simply running `nomnomd` with a set of Markdown files generates the resulting HTML files in the `build` output folder.

If recursive mode is turned on, all directories passed `nomnomd` will be traversed, and all `.md` files found will be processed.

During development, `nomnomd` can be run with the `--serve` flag to launch a little watching, hot-reloading development server on the given port. No output is written in serve mode.

[sheetleeten]: https://erkkah.github.io/sheetleeten
[nomnoml]: https://nomnoml.com
[highlight.js]: https://highlightjs.org
[pupa]: https://www.npmjs.com/package/pupa

repository: erkkah/nomnomd

repo_name: erkkah/nomnomd


text:
SGP30
=========

Library to read eCO2 and TVOC from the [SGP30 sensor](https://cdn-learn.adafruit.com/assets/assets/000/050/058/original/Sensirion_Gas_Sensors_SGP30_Datasheet_EN.pdf). Based on the _smbus2_ i2c library for ease of use.

It should be compatible with both Python 2 and 3

Quick usage-example:
--------------------

    from smbus2 import SMBusWrapper
    from sgp30 import SGP30
    import time

    with SMBusWrapper(1) as bus:
        sgp = SGP30(bus, baseline_filename=BASELINE_FILENAME+".TESTING")
        print("resetting all i2c devices")
        sgp.i2c_general_call()
        print(sgp.read_features())
        print(sgp.read_serial())
        sgp.init_sgp()
        for i in range(300):
			print(sgp.read_measurements())
			time.sleep(0.1)
		sgp.store_baseline()
        bus.close()

Current design considerations:
------------------------------
The class strives to to be light-weight and portable. It is currently a bit to tightly bound to the smbus2 class. In most cases I try to ease of readability rather than purity or speed.

Features that are known to be missing (listing in rough order of importance):
-----------------------------------------------------------------------------
* The handing of baseline values is not that great, it should probably be up to the end user to save and restore them as needed.
* Write doc-strings for all or at least most methods.
* reading raw-values.
* A more "driver like" class that takes care of all chip identification, polling at regular intervals, restoring baseline and so on.
* Run real hardware tests under Python3

Hardware notices:
-----------------
If you have the Adafruit board with built in level shifters and voltage regulator it is should work if you just plug in [SDA to pin 3, SCL to pin 5, VCC to pin 17 and GND to pin 20](https://pinout.xyz/pinout/i2c). You should then be able to find the SGP30 an address 0x58 using `i2cdetect -y 1`. If you get an error message  you probably need to enable i2c in the kernel using  [raspi-config and reboot](https://learn.sparkfun.com/tutorials/raspberry-pi-spi-and-i2c-tutorial>)

Feel free to contact me with bugs, questions or issues.


text:
# 1060 Are They Equal (25 分)

If a machine can save only 3 significant digits, the float numbers 12300 and 12358.9 are considered equal since they are both saved as $0.123 \times 10^5$ with simple chopping. Now given the number of significant digits on a machine and two float numbers, you are supposed to tell if they are treated equal in that machine.

## Input Specification:
Each input file contains one test case which gives three numbers $N$, $A$ and $B$, where $N (< 100)$ is the number of significant digits, and $A$ and $B$ are the two float numbers to be compared. Each float number is non-negative, no greater than $10^100$, and that its total digit number is less than $100$.

## Output Specification:
For each test case, print in a line `YES` if the two numbers are treated equal, and then the number in the standard form `0.d[1]...d[N]*10^k` (`d[1]`>0 unless the number is 0); or `NO` if they are not treated equal, and then the two numbers in their standard form. All the terms must be separated by a space, with no extra space at the end of a line.

Note: Simple chopping is assumed without rounding.

## Sample Input 1:
```
3 12300 12358.9
```

## Sample Output 1:
```
YES 0.123*10^5
```

## Sample Input 2:
```
3 120 128
```

## Sample Output 2:
```
NO 0.120*10^3 0.128*10^3
```

url: https://raw.githubusercontent.com/absop/PAT/a0dbd4944cdf95e88af2e60419a114f96c7f9f19/AdvancedLevel_C/1060 Are They Equal (25 分).md

repository: absop/PAT

filename: 1060 Are They Equal (25 分).md

repo_name: absop/PAT


text:
# Andres Vega
I am honored to nominate Andres Vega for the SPIFFE Steering Committee. Andres
is a SPIFFE/SPIRE champion who has helped the project and community extensively
grow. In addition to being a long time friend to the SPIFFE project and author
of the SPIFFE Turtle Book, Andres has spent countless hours helping many
organizations adopt, plan, and deploy SPIFFE environments. Most importantly,
Andres has always taken a community first approach which is vital for the
continued success of SPIFFE.

## Words from Andres
Andres answered the following questions in support of his nomination.

**What makes you a good fit for the SPIFFE Steering Committee?**
I have a been a contributor to the spiffe community for a number of yearsd. Some of my contributions to the project and its community include:

* Led the certification of the project to attain a Core Infrastructure Initiative Best Practices badge.
* Authored and led the CNCF SIG-Security assessment.
* Drove and represented the project moving from CNCF sandbox level into the incubation stage.
* Delivered a number of SPIFFE/SPIRE webinars and trainings.
* Coauthored "Solving the Bottom Turtle"

**What aspects of SSC participation are you most excited about?**
What excites me the most of SSC participation is voicing the needs of the end users in order to ease adoption and consumption of spiffe in production systems. My other side hustle is security advisory to the CNCF ecosystem. As such I'm hopeful to help crosspolinate spiffe integrations with other technologies in the ecosystem.

**Is there anything else you'd like to say as part of your nomination?**
Two other growth areas I'm passionate about about is democratizing the use of spire by setting it into a direction that is set and forget it. So easy that someone that does not possess domain expertise can consume it. And then, integrations, integrations, integrations. What I mean by that is I'd like to see a future of a more secure cloud native ecosystem where the top 50 OSS projects support SPIFFE authentication natively.

## Reference
**GitHub Handle:** anvega
**Email address:**<EMAIL_ADDRESS>
**Linkedin Profile:** https://www.linkedin.com/in/avegaarias/
**Current Affiliation:** VMware

repository: spiffe/spiffe

gha_language: Shell

repo_name: spiffe/spiffe