text:
---
hrs_structure:
  division: '1'
  volume: '3'
  title: '10'
  chapter: '132'
  section: 132-4.5
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0132-0004_0005
    parent: HRS0132
    name: >-
      132-4.5 Investigation of fires; immunity for information received from
      insurers
weight: 24025
title: Investigation of fires; immunity for information received from insurers
full_title: >-
  132-4.5 Investigation of fires; immunity for information received from
  insurers
---
**[§132-4.5] Investigation of fires; immunity for information received from insurers.** (a) The fire chief of each county may require any insurer in writing to release information relating to any investigation the insurer has made concerning a loss or potential loss due to fire of suspicious or incendiary origin which information shall include but not be limited to:

(1) An insurance policy relating to such loss;

(2) Policy premium records;

(3) History of previous claims; and

(4) Other relevant material relating to such loss or potential loss.

(b) If any insurer has reason to suspect that a fire loss to its insured's real or personal property was caused by incendiary means, the insurer shall furnish the county fire chief with all relevant material acquired during its investigation of the fire loss, cooperate with and take such action as may be required of it by the county fire chief, and permit any person ordered by the court to inspect any of its records pertaining to the policy and the loss. Such insurer may request the county fire chief to release information relating to any investigation the fire chief has made concerning any such fire loss of suspicious or incendiary origin.

(c) In the absence of fraud, malice, or criminal act, no insurer or person who furnishes information on its behalf, shall be liable for damages in a civil action or be subject to criminal prosecution for any oral or written statement made that is necessary to supply information required pursuant to this section.

(d) The county fire chief receiving any information furnished pursuant to this section shall hold the information in confidence until such time as its release is required in furtherance of a criminal or civil proceeding.

(e) The county fire chief, in person or by officers or members of the fire chief's fire department, may be required to testify as to any information in the fire chief's possession regarding the fire loss of real or personal property in any civil action in which any person seeks recovery under a policy against any insurance company for the fire loss. [L 1979, c 215, §1; gen ch 1985]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# ddcloud\_server\_backup

This resource enables Cloud Backup for a server and, optionally, configures its backup clients.

## Example Usage

```hcl
resource "ddcloud_server_backup" "myserver" {
  server            = "${ddcloud_server.myserver.id}"
  service_plan      = "Essentials"

  client {
    type            = "FA.Linux"
    schedule_policy = "6AM - 12PM"
    storage_policy  = "14 Day Storage Policy"
  }
}
```

## Argument Reference

The following arguments are supported:

* `server` - (Required) The Id of the server for which Cloud Backup will be enabled / configured.
* `service_plan` - (Required) The Cloud Backup service plan to use.
  Must be one of `Essentials`, `Advanced`, or `Enterprise`.
* `client` - (Optional) A list of Backup clients to be assigned to / configured on the server.
  **Note**: Once created, do not change the order of the backup clients in this list.
  * `type` - (Required) The type of backup client (e.g. `FA.Linux`).
  * `schedule_policy` - (Required) The name of the schedule policy to use (e.g. `6AM - 12PM`).
  * `storage_policy` - (Required) The name of the storage policy to use (e.g. `14 Day Storage Policy`).
  * `alert` - (Optional) The client's alerting configuration.
    * `trigger` - (Required) The trigger for backup client alerts.
      Must be one of `ON_FAILURE`, `ON_SUCCESS`, or `ON_SUCCESS_OR_FAILURE`.
    * `emails` - (Required) A list of one or more email addresses that alerts will be sent to.

## Attribute Reference

* `asset_id` - The asset Id assigned to the server by Cloud Backup.
* `client` - Computed attributes for the server's backup clients.
  * `client.id` - The Id assigned to the backup client by Cloud Backup.
  * `client.description` - A short description of the backup client type.
  * `client.download_url` - The URL where the backup client installer can be downloaded.
  * `client.status` - The client status (e.g. `Unregistered`, `Offline`, `Active`, etc).

## Import

Import of `ddcloud_server_backup` is not implemented yet.

license: MIT

extension: md

gha_language: Go

gha_license_id: MIT

license_type: permissive


text:
---
title: Installation
order: 1
---
# Laravel N+1 Query Detector

The Laravel N+1 query detector helps you to increase your application's performance by reducing the number of queries it executes. This package monitors your queries in real-time, while you develop your application and notify you when you should add eager loading (N+1 queries).

# Installation

You can install the package via composer:

```
composer require beyondcode/laravel-query-detector --dev
```

The package will automatically register itself.

repository: beyondcode/laravel-query-detector

branch_name: refs/heads/master

gha_language: PHP

repo_name: beyondcode/laravel-query-detector


text:
reactjs-bindings by Simon Meier<EMAIL_ADDRESS>based on Luite Stegemans
virtual-dom bindings.

to initiate:

    $ npm install

to build

    $ grunt

to watch for changes and rebuild

    $ grunt watch

repository: LumiGuide/blaze-react

repo_name: LumiGuide/blaze-react


text:
tabix
=====

This program heavily utilizes the tabix indexing scheme as developed by Heng Li.

Picard
======

The Picard project (http://picard.sourceforge.net) is used for its handling of BlockCompressedInputStreams (bgzip).
Portions of the picard code (for implementing tabix in java) were also modified from the picard project.

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

Guava
=====

AbstractIterator is used from the Guava library
(https://code.google.com/p/guava-libraries/) I incorporated it as
org.drpowell.util.AbstractPeekableIterator and removed a few dependencies
to elsewhere in Guava. Guava is distrubuted under the Apache License.

> Copyright (C) 2007 The Guava Authors
>
> Licensed under the Apache License, Version 2.0 (the "License");
> you may not use this file except in compliance with the License.
> You may obtain a copy of the License at
>
> http://www.apache.org/licenses/LICENSE-2.0
>
> Unless required by applicable law or agreed to in writing, software
> distributed under the License is distributed on an "AS IS" BASIS,
> WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> See the License for the specific language governing permissions and
> limitations under the License.

repository: bpow/varitas

repo_name: bpow/varitas


text:
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''

---

**What problem does this feature request solve?.**
A clear and concise description of what the problem is.

**Describe your proposed solution**
A clear and concise description of what you think should happen.

**Describe alternatives you've considered**
Where possible, please describe alternative solutions you have considered and subsequently opted against and why they weren’t implemented.

**Environment context**
- Socialstream version: #.#.#
- Jetstream stack: Inertia / Livewire
- Laravel version: #.#.#
- PHP version: #.#.#

repository: joelbutcher/socialstream

repo_name: joelbutcher/socialstream


text:
---
title:      "Estimation of the fractal dimension of a tumor volume with 3D box counting"
date:       2017-10-10 00:00:00
author:     "Antonio Rueda Toicen"
header-img: "img/tv_death_4.jpg"
comments: true
---

Here's a video tutorial that I prepared on 2014 using the Wolfram Language and its
(then new) Courseware Tools.

<https://youtu.be/HG4GmmKA9JI>

[The full code is on Github.](https://github.com/andandandand/fractal-dimension-of-brain-tumors-w-box-counting-algo "Wolfram Language repository for the tutorial")

extension: markdown

gha_language: JavaScript


text:
# Tags

> Tag a single image by URL:

```shell
curl -H "Authorization: Bearer <access_token>" https://api.clarifai.com/v1/tag/?url=http://www.clarifai.com/img/metro-north.jpg

```

> Or using a POST request:

```shell
curl -H "Authorization: Bearer <access_token>" --data-urlencode "url=http://www.clarifai.com/img/metro-north.jpg"  https://api.clarifai.com/v1/tag/
````

> Tag multiple images in a batch request, sending URLs:

```shell
curl -H "Authorization: Bearer <access_token>" --data-urlencode "url=http://www.clarifai.com/img/metro-north.jpg" -d "url=http://www.clarifai.com/img/metro-north.jpg"  https://api.clarifai.com/v1/tag/
````

> Tag multiple images in a batch request, uploading image files from local disk:

```shell
curl -H "Authorization: Bearer <access_token>" -F<EMAIL_ADDRESS>-F<EMAIL_ADDRESS>https://api.clarifai.com/v1/tag/
```

`GET https://api.clarifai.com/v1/tag/`

Tag an image with recognized objects and descriptive tags.  Returns tags and associated
confidences (probabilities).

## Request parameters

Parameter | Description
--------- | -----------
url | URL of the content to be recognized.
model | Optional. Specify the type of model to process the images with. Currently must be 'default'.
local_id | User-supplied identifier, returned with the result for each image for convenience when associating results with requests. If not supplied, the request URL is returned when available.
select_classes | Optional. Comma-separated list of class names (string).
Used to select a specific set of recognized tags to be returned in the response.  See [Selecting tags](#selecting-tags) for details.

## Selecting tags

> Get predictions for a specific set of tags using the `select_classes` request param:

```shell
curl -H "Authorization: Bearer <access_token>" --data-urlencode "url=http://www.clarifai.com/img/metro-north.jpg"  -d "select_classes=smile,frowning,laughing" https://api.clarifai.com/v1/tag/
```

Normally we return the top recognized tags by predicted confidence.
For some applications, the top tags are less useful than getting predictions for a specific set
of tags.  We support this using the `select_classes` request parameter.

When `select_classes` is provided in the request, only results for the requested classes are
returned.

## Response

> Example response with a single image.

```json
{"meta": {
   "tag": {
       "config": "cf0267260d65c1312cac67ab2474dbdc",
       "model": "default",
       "status_code": "OK",
       "timestamp":<PHONE_NUMBER>.483851}},
 "results": [
     {"docid_str": "31fdb2316ff87fb5d747554ba5267313",
      "local_id": "http://www.clarifai.com/img/metro-north.jpg",
      "result": {
          "tag": {
              "classes": [
                  "train",
                  "subway",
                  "railroad",
                  "railway",
                  "station",
                  "rail",
                  "transportation",
                  "urban",
                  "underground",
                  "night",
                  "traffic",
                  "commuter",
                  "bridge",
                  "city",
                  "road",
                  "national park",
                  "public",
                  "platform",
                  "street",
                  "blur"],
              "probs": [
                  0.9994779825210571,
                  0.9983398914337158,
                  0.9967546463012695,
                  0.9949972033500671,
                  0.9938348531723022,
                  0.9938316345214844,
                  0.989970326423645,
                  0.9786827564239502,
                  0.9764524698257446,
                  0.9714784026145935,
                  0.9520049095153809,
                  0.9501165151596069,
                  0.9497720003128052,
                  0.9494657516479492,
                  0.9481779336929321,
                  0.9384146928787231,
                  0.938301682472229,
                  0.9342441558837891,
                  0.9231494665145874,
                  0.9211686849594116]
              }
          },
      "status_code": "OK",
      "status_msg": "OK"}
 ],
 "status_code": "OK",
 "status_msg": "All images in request have completed sucessfully."
}
```

Image and video recognition results are returned in the `results` array,
one result per image.

Each result
has its own `status_code` and `status_msg` which allows for individual images in a batch to succeed
even if some fail.

Notable response parameters:

Parameter | Description
--------- | -----------
docid_str | A unique string identifying each result. Used when sending [feedback](#feedback).
local_id | User-supplied identifier, echoed back in each result if supplied in the request, or the URL of the image is returned if available.
classes | An array of tags recognized from this image or video segment.
probs | An array of confidences (probabilities) associated with the tags returned in `classes`.

# Feedback

## HTTP Request

`GET|POST https://api.clarifai.com/v1/feedback/`

This endpoint provides the ability to provide feedback to the API about images that were previously processed, for example to correct errors made by the recognition engine.

We highly encouraged integrating feedback into your application as this dramatically improves the system over time. You or your users can correct errors made by the recognizer. For example, if the system returned "cat" for an image of a dog, you can send a message with add_tags="dog", remove_tags="cat".

Requests to the feedback endpoint can be made with either http GET or POST methods.

<aside class="notice">
Feedback requests are always free. Vote early, vote often!
</aside>

<aside class="warning">
Abuse by providing poor quality or incorrect feedback, may result in account suspension or
termination, as it can affect the service for other users.
</aside>

## Request parameters

Parameter | Description
--------- | -----------
docids | Comma-separated list of docids (strings) that identifies which images/video the feedback applies to. Use the value of the `docid_str` field in the tag response.
url |  Url that identifies the image/video the feedback applies to. Multiple urls can be sent, but since URLs can contain commas, each must be sent as a separate HTTP request param.
add_tags | comma-separated list of tags for positive feedback. UTF-8 encoded.
remove_tags | comma-separated list of tags for negative feedback. UTF-8 encoded.
similar_docids | comma-separated list of docids that are similar to the input docids.
dissimilar_docids | comma-separated list of docids that are dissimilar to the input docids.
search_click | comma-separated list of search terms that generated clicks on a set of docids.

One and only one parameter in the feedback request must identify the image: either `url` or
`docids`.

## Positive feedback

> Add tags or give positive feedback for tags to a docid:

```shell
curl -H "Authorization: Bearer <access_token>" -d "docids=78c742b9dee940c8cf2a06f860025141" -d "add_tags=car,dashboard,driving"  https://api.clarifai.com/v1/feedback/
```

> Add tags, specifying the image by URL instead of docid:

```shell
curl -H "Authorization: Bearer <access_token>" --data-urlencode "url=http://www.clarifai.com/img/metro-north.jpg" -d "add_tags=train station,railway station"  https://api.clarifai.com/v1/feedback/
```

> Suggest tags for multiple images in a single request, with a comma-separated list of docids:

```shell
curl -H "Authorization: Bearer <access_token>" -d "docids=78c742b9dee940c8cf2a06f860025141,5849206sdee940c8cf2a06f8792384059"  -d "search_click=cat,hat,mat" https://api.clarifai.com/v1/feedback/
```

Confirm correct and useful tags, or suggest missing tags, using the `add_tags` field.

If the user believes additional tags are relevant to the given image, they can be provided in the
`add_tags` argument. `add_tags` accepts a comma-separated list of tags in UTF-8 encoding.

## Negative feedback on errors

> Remove tags or give negative feedback for tags to a docid:

```shell
curl -H "Authorization: Bearer <access_token>" -d "docids=78c742b9dee940c8cf2a06f860025141" -d "remove_tags=sky,clean,red"  https://api.clarifai.com/v1/feedback/
```

If the user believes tags were are not relevant to the given image, they can be provided in the
`remove_tags` argument. `remove_tags` accepts a comma-separated list of tags in UTF-8 encoding.

## Suggest similar items

> Add similar docids for a given docid:

```shell
curl -H "Authorization: Bearer <access_token>" -d "docids=78c742b9dee940c8cf2a06f860025141" -d "similar_docids=fc957ec10abcc0f4507475827626200a" https://api.clarifai.com/v1/feedback/
```

If there is a notion of similarity between images, this can be fed back to the system by providing
an input set of `docids` and `similar_docids`, a comma-separated list of docids that are similar
to the input docids.

## Suggest dissimilar items

> Add dissimilar docids for a given docid:

```shell
curl -H "Authorization: Bearer <access_token>" -d "docids=78c742b9dee940c8cf2a06f860025141" -d "dissimilar_docids=acd57ec10abcc0f4507475827626785f" https://api.clarifai.com/v1/feedback/
```

If there is a notion of similarity between images, this can be fed back to the system by providing
an input set of `docids` and `dissimilar_docids`, a comma-separated list of docids that are
dissimilar to the input docids.

## Search result click feedback

> Provide feedback on which items were clicked after searching for the specified tags.

```shell
curl -H "Authorization: Bearer <access_token>" -d "docids=78c742b9dee940c8cf2a06f860025141"  -d "search_click=cat" https://api.clarifai.com/v1/feedback/
```

This is useful when showing search results in response to a query, to provide feedback that the
search result was relevant to the query. The `docids` parameter identifies the image that was
clicked, and the `search_click` parameter is a comma-separated list of search terms that
generated the search result.

## Feedback response

> Example feedback response:

```json
{
  "status_code": "OK",
  "status_msg": "Feedback sucessfully recorded. "
}
```

The Feedback response contains `status_code` and `status_msg`.

# Info and API limits

The API enforces certain limits on requests.

For example, the API enforces limits on the size of images that can be processed.
Too small of an image would result in poor recognition results due to low image resolution, and
too large of an image slows down processing unnecessarily due to network transfer and resizing
operations on the server.

## Info

> Example response

```json
{"embed_allowed": true,
 "max_video_batch_size": 1,
 "max_image_size": 1024,
 "max_batch_size": 128,
 "min_image_size": 224,
 "max_image_bytes": 10485760,
 "max_video_size": 1024,
 "min_video_size": 224,
 "max_video_bytes": 104857600,
 "api_version": 0.1,
 "max_video_duration": 1800}
```

The `/info` endpoint returns current API details including limits and thresholds on requests.

The response includes:

Field | Description
--------- | -----------
max_batch_size | The maximum number of images allowed to process in one bach request.
max_image_size | The maximum allowed image size (on the minimum dimension).
min_image_size | The minimum allowed image size (on the minimum dimension).

repository: alissaom/slate

repo_name: alissaom/slate


text:
# Racket GraphViz Integration

The goal of this library is to make composition of Racket [Pict](https://docs.racket-lang.org/pict/)
and [Graphviz Diagrams](https://www.graphviz.org/) possible.

The composition is made possible through:
* You can use graphviz diagrams as normal picts
* You can use any Pict as node shape of graphviz diagrams

For example, in the following program note that the shapes for nodes "c" and "f" and also the node with fish shape
are racket shapes. Rest of the nodes use a shape provided by graphviz.

```racket
(digraph->pict
 (make-digraph
  `(["a" #:shape "diamond" #:fillcolor "lightgray" #:style "filled"]
    ["b" #:shape ,(cloud 60 30) #:label "c"]
    ["c" #:shape ,(standard-fish 100 50 #:open-mouth #t #:color "Chartreuse")
         #:label ""]
    "d"
    "a -> b -> c"
    "a -> d -> c"
    (subgraph "stdout" #:style "filled" #:fillcolor "cyan"
              (["f" #:shape ,(file-icon 50 60 "bisque")]
               "g"
               "f -> g"))
    "d -> g")))
```

![](images/custom-shapes.svg)

As another example, take a look at [dirtree.rkt](examples/dirtree.rkt) which dynamically generates a directory tree.

![](images/dirtree.svg)

Notice how dirtree.rkt has used `make-vertex` and `make-edge` functions:

```racket
...
(define root (make-vertex (path->string name) #:shape shape))
...
(make-edge root-node sub-node)
...
```

You can pass a list of vertex and edges to `make-digraph` to create a digraph, and use `digraph->pict`
to convert it to a pict.

```racket
(define d (make-digraph (list v1 v2 (make-edge v1 v2))))
(digraph->pict d)
```

repository: pykello/racket-graphviz

gha_language: Racket

repo_name: pykello/racket-graphviz


text:
---
layout: default
---

# 1994-02-04 - STEG: a real-life use for steganography

## Header Data

From<EMAIL_ADDRESS>(Eric Hughes)

To<EMAIL_ADDRESS>Message Hash: 6f834c4626d052173d5ede50980c1771ec1c6b79098328bae1cd12fef233cac2

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-02-04 18:45:10 UTC

Raw Date: Fri, 4 Feb 94 10:45:10 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Eric Hughes)
Date: Fri, 4 Feb 94 10:45:10 PST
To<EMAIL_ADDRESS>Subject: STEG: a real-life use for steganography
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I had an extremely interesting conversation with a fellow last night,
say, X.  A mutual friend of ours had steered him towards me.

X has contacts in a country C which will remain nameless.  The
government of C is extremely repressive and has a large internal
police force.  The situation, evidently, is one similar to the old
USSR, where masks behind masks were used in daily life, little is
exactly as it appears, and the default discourse is sideways speaking.

The scenario is almost worst-case.  There is a need for steganography,
since the use of cryptography is grounds for suppression; likewise
there is a need for covert channels.  There is a need for
double-blinding of identities, since one's friends may be difficult to
detect.  And so on.

The aspect that _is_ good is that C is not the whole world, and there
are plenty of us not in C.  The first most useful facility to set up,
X thinks, is simply news from outside of C as a bypass of the media in
C--wire service articles about C, for example, as well as a feed of
the newsgroup "soc.culture.<C>".

Here's the technique we came up with last night.  C has an indigenous
music M which is periodically performed in the United States.  We were
thinking about pressing short-run CD's of these live performances.  We
all know where the news feeds go.  The CD's would be distributed via
standard music channels and would be surprisingly brisk sellers.  The
costs of the project can evidently be footed by willing members of the
M industry in C.

Now let me address the standard comment "Oh, steganography completely
solves that problem."  Please.  That's like saying, "Oh, just use an
internal combustion engine to solve your long distance transport
problems."  Such statements are a failure of imagination and
seriousness.

A practical system to carry this project out is quite large.  I see at
least the following pieces needed:

 -- A facility to gather the data being put on the disks.  This by
itself is no trivial task, since it involves the collection of many
disparate sources.

 -- An authoring system to arrange the data, once collected, into a
usable structure.

 -- An encryption system for the arranged data.  Such a system can't
treat the data as one long stream, because of the segmented nature of
the data.  The ability to mount the CD as a file system would be good
leverage for other programmers.

 -- A mastering system to combine a music master CD (done separately)
and a data master (in some format) into a new music master CD.  This
will, at the least require a machine with a CD reader and writer.
Blank media, FYI, for a CD writer are about $20/disk.  The CD writer
is about $5K.  These numbers are approximate and falling rapidly.

 -- A CD pressing facility.  These are commercially available at quite
reasonable cost in quantities in the 100's.

 -- A CD distribution system.  This will likely be the M industry, and
thankfully the details of international shipping and customs will be
taken care of, as well as retail distribution.

 -- A decryption system to get the data off the CD.

 -- Client software to make use of the information.  It need not all
be in text format.

 -- A key distribution system.  A secret key per CD and word of mouth
may be sufficient.  A system to make rememberable sentences out of an
arbitrary 128 bits (and the inverse) would be useful to facilitate
word of mouth.

This is no small task.  Those interested in participating may start
working on any of the above.  The tasks are fairly separable.  Here
are some that I can identify as critical.

 -- A standard for encoding data into the low bits of an audio CD.
This will likely require a lot of specific knowledge of the low level
encoding and error correction systems used in CD's.  I do know that
they are not simple, being much more than bit-correcting linear codes.

 -- A standard for the encoding of file system data onto these low
bits.  This should be a separate document, even though the design of
this will be influenced by the bit encoding standard.  Some adaptation
of existing file system standards may be appropriate.

 -- A standard for the encryption format for the file system.  It may
be that Matt Blaze's CFS cryptograpy can be lifted wholesale.

 -- Multiplatform software support for all of the above.

I am pleased to have a real example to work on, rather than a lot of
wixering about hypotheticals.

I welcome discussion of this topic.

Eric

{% endraw %}
```

## Thread

+ Return to [February 1994](/archive/1994/02)

+ Return to "["Alan (Miburi-san) Wexelblat" <wex@media.mit.edu>](/authors/alan_miburisan_wexelblat_wex_at_media_mit_edu_)"
+ Return to "[dm@hri.com](/authors/dm_at_hri_com)"
+ Return to<EMAIL_ADDRESS>(Eric Hughes)](/authors/hughes_at_ah_com_eric_hughes_)"
+ Return to<EMAIL_ADDRESS>(Paul Robichaux)](/authors/paul_at_poboy_b17c_ingr_com_paul_robichaux_)"
+ Return to "[Phil Karn <karn@qualcomm.com>](/authors/phil_karn_karn_at_qualcomm_com_)"

+ 1994-02-04 (Fri, 4 Feb 94 10:45:10 PST) - STEG: a real-life use for steganography -<EMAIL_ADDRESS>(Eric Hughes)_
  + 1994-02-04 (Fri, 4 Feb 94 12:10:14 PST) - [STEG: a real-life use for steganography](/archive/1994/02/0142813195b054131b4e85d270c3a5932a0e96d5ca32432dc54b3a510b898d1a) - _"Alan (Miburi-san) Wexelblat"<EMAIL_ADDRESS>  + 1994-02-07 (Mon, 7 Feb 94 09:46:26 PST) - [Re: STEG: a real-life use for steganography](/archive/1994/02/d716ff57355e41921348b0622f2c6c9112a2b399b6ad5fbcc9b579f7724931e6) -<EMAIL_ADDRESS>  + 1994-02-08 (Mon, 7 Feb 94 23:10:43 PST) - [Re: STEG: a real-life use for steganography](/archive/1994/02/f9b94b14a83cae1160fccc53699c0b2757d0273a1e178ed8f4fca0b467da434b) - _Phil Karn<EMAIL_ADDRESS>    + 1994-02-08 (Tue, 8 Feb 94 07:10:51 PST) - [Re: STEG: a real-life use for steganography](/archive/1994/02/733f5c699c360e3eb45b165638009073ac7d77cb9d16c117d2dd0f59ebe3e4dc) -<EMAIL_ADDRESS>(Paul Robichaux)_


text:
---
layout: post
title:  "how to fix Multiple commands produce issue in Xocde 10"
subtitle: ""
categories: ""
author: Geek
date:   2018-11-01 15:34:56 -0400
background: '/img/posts/04.jpg'
---
way 1:

In Xcode, go to File->Project/Workspace settings.

Change the build system to Legacy Build system.

https://stackoverflow.com/questions/50718018/xcode-10-error-multiple-commands-produce

way 2:

remove one file with same name in "Copy Bundle Resourrces" in Build Phases in Xcode

I met same this error: two Localizable.strings files are copied from separate location. It is fixed by removing one Localizable.strings file.

way 3:

Check "Copy only when installing"

https://github.com/wix/react-native-navigation/issues/3608

url: https://raw.githubusercontent.com/geek1250/geek1250.github.io/47c9cdddd8c816a87ae573d77fa770cdb8cfec2c/_posts/2018-11-01-how to fix Multiple commands produce issue in Xocde 10.md

gha_language: HTML


text:
# Karmada Roadmap

This document defines a high level roadmap for Karmada development and upcoming releases.
Community and contributor involvement is vital for successfully implementing all desired items for each release.
We hope that the items listed below will inspire further engagement from the community to keep Karmada progressing and shipping exciting and valuable features.

## 2023 H1
- Cluster scheduling group
- Multiple schedulers support
- Application-level failover
- Multi-cluster HPA (Horizontal Pod Autoscaling)
- Karmada operator
- ResourceInterpreter include third-party CRD resources
- Karmada playground

## 2023 H2
- Karmada Dashboard - alpha release
- Multi-cluster workflow
- Cluster addon management
- Multi-cluster Application
- Multi-cluster monitoring
- Multi-cluster logging
- Multi-cluster storage
- Multi-cluster RBAC
- Multi-cluster networking
- Data migration across clusters
- Integration with terraform
- Cluster lifecycle management
- Image registry across clouds
- Multi-cluster Service Mesh solutions

repository: karmada-io/karmada

repo_name: karmada-io/karmada


text:
---
layout: post
title: "Interplay of spin-orbit coupling and hybridization in Ca3LiOsO6 and
   Ca3LiRuO6"
urlLink: https://dx.doi.org/10.1103/PhysRevB.96.184426
categories: publications
---
By: Calder, Singh, Garlea *etal*.

**PHYSICAL REVIEW B**, Volume:96, Issue:18, Article Number:184426

filename: 2017-11-22-PHYSICAL REVIEW B.md


text:
# atom-ide-base

Atom IDE packages for Atom

![Build Status (Github Actions)](https://github.com/atom-ide-community/atom-ide-base/workflows/CI/badge.svg)
[![Dependency Status](https://david-dm.org/atom-ide-community/atom-ide-base.svg)](https://david-dm.org/atom-ide-community/atom-ide-base)
[![apm](https://img.shields.io/apm/dm/atom-ide-base.svg)](https://github.com/atom-ide-community/atom-ide-base)
[![apm](https://img.shields.io/apm/v/atom-ide-base.svg)](https://github.com/atom-ide-community/atom-ide-base)

## Features

This package is an all-in-one package that installs all the packages that provide Atom IDE features:

- `atom-ide-datatip`
- `atom-ide-signature-help`
- `atom-ide-hyperclick`
- `atom-ide-definitions`
- `atom-ide-outline`
- `linter`
- `linter-ui-default`
- `intentions`
- `atom-ide-markdown-service`

It also provides the TypeScript types for atom-ide packages.

## Usage

Just install and enjoy.

## Using Types

Install the packages as an npm package:

```
npm install --save-dev atom-ide-base
```

Then import the types like the following:

```ts
import { BusySignalServie } from "atom-ide-base"
```

See the "types/\*.d.ts" files to become familiar with the API.

## Using the common files for IDE packages

Install the packages as a dependency:

```
npm install --save atom-ide-base
```

Then import the files you need:

```ts
import { ProviderRegistry } from "atom-ide-base/commons-atom/ProviderRegistry"
```

## Contributing

- Let me know if you encounter any bugs.
- Feature requests are always welcome.


text:
## ONLY DO THIS IF YOU DO NOT HAVE RVM OR RBENV

One time bundler setup:

```bash
mkdir ~/.bundle
echo 'BUNDLE_PATH: .vendor/bundle' >> ~/.bundle/config
```

This will install all gems into your working directory, allowing you to have different gem versions.

repository: apextw/advanced-rwd

repo_name: apextw/advanced-rwd


text:
**L2 deposit and withdraw test**

* L1: ethereum goerli
* L2: matic mumbai

```
cd ../

// check the balance in L1
hh --network goerli run scripts/LeedoBalance.js

// claim 2 cards
hh --network goerli run scripts/LeedoClaims.js

// stake 2 cards
hh --network goerli run scripts/LeedoVaultStaking.js

// approve and depositFor to deposit to matic L2
hh --network goerli run scripts/LeedoDepositToL2.js

// check the balance in L2   (it takes 7 to 15 mins)
hh --network mumbai run scripts/MaticBalance.js

// burn to withdraw to ethereum L1
hh --network mumbai run scripts/MaticWithdrawBurn.js

// exit to withdraw to ethereum L1
hh --network goerli run scripts/LeedoWithdrawExit.js
```

branch_name: refs/heads/main


text:
README FILE

CertPinBasic for Android 4.4 (KitKat) and above
By The APPrentices (SADP)
[05/02/2014]

CONTENTS

I.	MINIMUM SYSTEM REQUIREMENTS
II.	DEVELOPER TOOLS
III.	FEATURES

I. MINIMUM SYSTEM REQUIREMENTS

Android Phone/Tablet Device or Emulator
* KitKat (Android 4.4) or higher
* Minimum SDK Version: 18
* Target SDK Version: 19

II. DEVELOPER TOOLS

* Eclipse IDE for Android (Java)
* Visual Studio Professional 2012
* Microsoft Windows Azure - SQL Database
			  - Azure Website (certificate pinned)
* ASP.NET MVC5

III. FEATURES

* Android security app that demonstrates certificate pinning.
* Secure mobile app that counters MITM attacks.
* User authentication

Copyright © 2014

Edward Reyes
Annie Thornton

CMPE 277: Smartphone Application Development
Project

San Jose State University

repository: AnnieMT/android-certificate-pinning

repo_name: AnnieMT/android-certificate-pinning


text:
# Accessibility

The `FPrimitive` library contains a way to express access on certain parts of the domain/application.
A critical function that can be revoked from running? A password or access key that should only be read once? ...

Any part can be expressed as a `Access<_, _>` type which defines a set of rules before the resource can be accessed.

For example, the access key config value should only be accessed once:

```fsharp
// F#
let (getAccessKeyOnce : Access<unit, string>) =
  Access.func (fun () -> "secret key")
  |> Access.once
```
```csharp
Access.Function1(() => "secret key").Once()
```

The `Access` function can then be evaluated, and will result in a `Result<_, _>` type; indicating either a successful or faulted access.

```fsharp
// F#
let (result : Result<string, string list>) =
  getAccessKeyOnce |> Access.eval ()
```
```csharp
// C#
AccessResult<string> result = getAccessKeyOnce.Eval()
```

## Revokability

The library comes with several features, one of which is revokability. When the `Access.revokable`/`.Revokable()` is added to the pipeline;
the resulting `Access` type can be revoked by calling `Access.revoke`/`.Revoke()` on the `Access` type. This makes the access part manually controlable.

The `Access` type can also be revoked automatically with these pipeline features:
* `Access.revokedAfter (TimeSpan)`/`.RevokedAfter(TimeSpan)`
* `Access.revokedWhen (IObservable)`/`.RevokedWhen(IObservable)`

license: Unlicense

repository: stijnmoreels/FPrimitive

gha_language: F#

gha_license_id: Unlicense

repo_name: stijnmoreels/FPrimitive


text:
---
layout: default
title: Symbols
nav_order: 3
parent: API Reference
permalink: /api/symbols
---

# Pract Symbols

> Warning: API Documentation is still a work in progress, and Pract's feature set has not yet been finalized.

See: [Events and Symbols](../basic/eventssymbols) for a more in-depth guide on how to use the basic Pract symbols

## Pract.None

Represents a value that should be assigned to "nil" on a modified Instance, since Pract cannot read the literal value `nil` as a table value in props.

## Pract.Attributes

Can be used as a key in the props of an Instance-modifying element. Will assign/modify/remove attributes on this instance via `instance:SetAttribute()`. The value specified in props should be typed as `{[string]: any}`, or a dictionary with string keys (the attribute names) and attribute-compatible values.

Example:
```lua
local function FrameWithAttribute(props: {})
    return Pract.create('Frame', {
        [Pract.Attributes] = {
            SomeAttributeName = 'Some Attribute Value',
        }
    })
end
```

For `Pract.decorate` and `Pract.index` elements, these attributes will be removed when unmounted. For `Pract.create` and `Pract.stamp`, they will not be removed since the instances will be destroyed by Pract regardless.

## Pract.CollectionServiceTags

Can be used as a key in the props of an Instance-modifying element. Will assign/modify/remove tags on this instance via `CollectionService:AddTag` and `CollectionService:RemoveTag`. The value

For `Pract.decorate` and `Pract.index` elements, these tags will be removed when unmounted. For `Pract.create` and `Pract.stamp`, they will not be removed since the instances will be destroyed by Pract regardless. The value specified in props should be typed as `{string}`, or an array of strings.

Example:
```lua
local function FrameWithTags(props: {})
    return Pract.create('Frame', {
        [Pract.CollectionServiceTags] = {'ApplyColorScheme', 'Foo'}
    })
end
```

## Pract.Children

Can be used as a key in the props for any element type that accepts props. The value in props should be typed as `Pract.ChildrenArgument`, or `{[any]: Element | boolean | nil}`. The keys of this table will be converted to a string via `tostring` and used as the [host child name](../basic/templatingelements#host-context) of the element at the corresponding value.

Any `boolean` or `nil` typed elements in the children table will be ignored. This allows for the following kinds of conditional expressions to be used:
```lua
local function ConditionalChild(props: {isGlowing: boolean})
    return Pract.stamp(script.CardTemplate, {
        [Pract.Children] = {
            Glow = props.isGlowing and Pract.stamp(script.GlowTemplate)
                -- If this condition evaluates to false, we ignore this child.
        }
    })
end
```

Please note that if you provide a `children` argument to `Pract.create`, `Pract.decorate`, or `Pract.stamp`, the argument provided will overwrite the `Pract.Children` key specified in props.

## Pract.AttributeChangedSignals

Can be used as a key in the props of an Instance-modifying element. Will connect listeners to an event retrieved via `instance:GetAttributeChangedSignal()`. The value in props should be typed as `{[string]: (rbx: any) -> ()}`, or a dictionary with the attribute names as keys, and the event listeners themselves as values.

Example:
```lua
local function FrameWithAttributeDetection(props: {})
    return Pract.create('Frame', {
        [Pract.AttributeChangedSignals] = {
            Foo = function(rbx: Frame)
                print("The attribute 'Foo' of", rbx:GetFullName(), "changed!")
            end,
        }
    })
end
```

## Pract.PropertyChangedSignals

Can be used as a key in the props of an Instance-modifying element. Will connect listeners to an event retrieved via `instance:GetPropertyChangedSignal()`. The value in props should be typed as `{[string]: (rbx: any) -> ()}`, or a dictionary with the property names as keys, and the event listeners themselves as values.

Example:
```lua
local function FrameWithAbsoluteSizeDetection(props: {})
    return Pract.create('Frame', {
        [Pract.PropertyChangedSignals] = {
            AbsoluteSize = function(rbx: Frame)
                print("The absolute size of", rbx:GetFullName(), "changed!")
            end,
        }
    })
end
```
## Pract.OnMountWithHost

Can be used as a key in the props of an Instance-modifying element. Will fire the listener when the element is mounted in a defered thread. The value in props should be typed as `(rbx: any, props: any, setOnCleanup: (cleanupCallback: () -> ()) -> ()) -> ()`

Example:
```lua
type Props = {}
local function TweeningFrameOnMount(props: Props)
    return Pract.create('Frame', {
        [Pract.OnMountWithHost] = function(
            rbx: Frame,
            props: Props,
            setOnCleanup: (
                cleanupCallback: () -> ()
            ) -> ()
        )
            -- Note: It is usually not recommended that you directly set an instance's properties
            -- through events, and handle it through Pract props instead. In the case of tweens
            -- though, it is better that we directly set these properties here so that the tween
            -- takes care of these changes, rather than being managed by Pract in any way.
            rbx.Position = UDim2.fromScale(0, 0)
            rbx.AnchorPoint = Vector2.new(0, 0)

            local tween = game:GetService('TweenService'):Create(
                rbx,
                TweenInfo.new(10),
                {
                    Position = UDim2.fromScale(1, 1)
                    AnchorPoint = Vector2.new(1, 1)
                }
            )
            tween:Play()

            -- We can stop and reset our tween if the component is unmounted while it tweening
            setOnCleanup(function()
                tween:Stop()
            end)
        end,
    })
end
```

## Pract.OnUpdateWithHost

Can be used as a key in the props of an Instance-modifying element. Will fire the listener when the element is updated in a defered thread. The value in props should be typed as `(rbx: any, props: any) -> ()`

Example:
```lua
type Props = {}
local function PrintsOnUpdate(props: Props)
    return Pract.create('Frame', {
        [Pract.OnUpdateWithHost] = function(rbx: Frame, props: Props)
            print("The component managing", rbx:GetFullName(), "has updated!")
        end,
    })
end
```

## Pract.OnUnmountWithHost

Can be used as a key in the props of an Instance-modifying element. Will fire the listener when the element is unmounted in a defered thread. The value in props should be typed as `(rbx: any) -> ()`

```lua
type Props = {}
local function PrintsOnUpdate(props: Props)
    return Pract.create('Frame', {
        [Pract.OnUnmountWithHost] = function(rbx: Frame)
            print("The component managing", rbx:GetFullName(), "was unmounted!")
        end,
    })
end
```


text:
# twitter-unfollow-alert
Unfollow Alert is an application that notifies you when someone unfollows you.
# SETUP
You will need to edit AppSettings.json for Twitter Authentication Tokens.
```json
  "App.Configurations": {
    "AuthConfig": {
      "CONSUMER_KEY": "YOUR CONSUMER KEY",
      "CONSUMER_KEY_SECRET": "YOUR CONSUMER KEY SECRET",
      "ACCESS_TOKEN": "YOUR ACCESS TOKEN",
      "ACCESS_TOKEN_SECRET": "YOUR ACCESS TOKEN SECRET"
    },
    "TweetConfig": {
      "Username": "tolgakisin",
      "TweetCountPerRequest": "5000",
      "ScheduleTimeAsMinute": "5"
    }
  }
```
* Username: Your Twitter username
* TweetCountPerRequest: Followers count per request
* ScheduleTimeAsMinute: Schedule Time as minute for the service to run

# BACKGROUND SERVICE
If you want to start this app as a Linux Daemon, you need to add ```UseSystemd()``` to Program.cs

```cs
public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .UseSystemd()
                .ConfigureServices((hostContext, services) =>
                {
                    IConfiguration configuration = hostContext.Configuration;
                    AuthConfig authConfig = configuration.GetSection("App.Configurations:AuthConfig").Get<AuthConfig>();
                    services.AddSingleton(authConfig);
                    TweetConfig tweetConfig = configuration.GetSection("App.Configurations:TweetConfig").Get<TweetConfig>();
                    services.AddSingleton(tweetConfig);

                    services.AddSingleton<ITwitterService, TwitterService>();

                    services.AddHostedService<Worker>();
                });
```

# PUBLISH

dotnet publish -o artifact

## Linux
To promote the application as a Daemon, create the "twitter-unfollow-alert-worker.service" file under the "/etc/systemd/system" directory.
```
[Unit]
Description=Twitter Unfollow Alert Worker

[Service]
Type=notify

WorkingDirectory=/srv/TwitterUnfollowAlertScheduler.Worker

ExecStart=/usr/bin/dotnet /srv/TwitterUnfollowAlertScheduler.Worker/TwitterUnfollowAlertScheduler.Worker.dll
SyslogIdentifier=Worker
User=root
Restart=always
RestartSec=5

Environment=DOTNET_ROOT=/opt/rh/rh-dotnet31/root/usr/lib64/dotnet

[Install]
WantedBy=multi-user.target
```

When the .service file is prepared, the service is enabled by running the ```systemctl daemon-reload``` command

#### Run ```systemctl status twitter-unfollow-alert-worker.service``` to get information about the status of the service
![Unfollow Alert Status](https://i.imgur.com/MWx8LPQ.jpeg)

# DEMO
![Unfollow Alert Unfollowers](https://i.imgur.com/FcdB1lw.jpeg)

repository: tolgakisin/twitter-unfollow-alert

repo_name: tolgakisin/twitter-unfollow-alert


text:
# OkBuck
[ ![Download](https://api.bintray.com/packages/piasy/maven/OkBuck/images/download.svg) ](https://bintray.com/piasy/maven/OkBuck/_latestVersion)
[![Master branch build status](https://travis-ci.org/Piasy/OkBuck.svg?branch=master)](https://travis-ci.org/Piasy/OkBuck)
[![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-OkBuck-green.svg?style=flat)](https://android-arsenal.com/details/1/2593)

A gradle plugin that helps developer migrate to code with Android Studio + Gradle, but build && install with buck.

Only ~~Twelve~~ **Ten** line config to migrate from Android Studio + gradle to facebook BUCK.

[中文版](README-zh.md)

## Why OkBuck?
Android Studio + Gradle has been many Android developers' option, and to migrate to buck, there are many works to be done, both difficult and buggy. OkBuck aims to provide a gradle plugin, which will do these buggy job for you automaticlly after several lines configuration.

Further more, you can still use OkBuck to maintain your BUCK build system when your gradle configurations changes, OkBuck let you even needn't know how to write the magic BUCK script!

## What will OkBuck do for you?
+  Generate `.buckconfig`.
+  Copy third-party libraries' jar/aar files to your rootProject directory.
+  Generate `BUCK` file for third-party libraries and each sub modules.
+  After you run `./gradlew okbuck` in your rootProject root directory, you can run `buck install app` now (suppose your application module names `app`).

## How to use OkBuck?
1. Add this lines into buildscript dependencies part of root rootProject build.gradle: `classpath "com.github.piasy:okbuck-gradle-plugin:${latest version}"`

2. Add this line into root rootProject build.gradle: `apply plugin: 'com.github.piasy.okbuck-gradle-plugin'`

3. Add this `okbuck` block into root rootProject build.gradle:

    ```gradle
    okbuck {
        target "android-23"
        overwrite true
        resPackages = [
            'dummylibrary': 'com.github.piasy.okbuck.example.dummylibrary',
            'app': 'com.github.piasy.okbuck.example',
        ]
    }
    ```

    +  `android-23` works equally with `compileSdkVersion 23`;
    +  ~~`debug.keystore` and `debug.keystore.properties` are signing related file, which should be put under **application module's root directory**~~
    +  no need to specify signing config anymore:
      +  if you have already set **only one** signing config in your build.gradle
      +  but you need to configure git to ignore your signing secrete, add this line to your **root rootProject .gitignore file**: `.okbuck/keystore`
      +  if you have multiple signing config, or you want put your signing config in another dir which **under your root rootProject dir**, you can set it like below, `keystoreDir` is used to config the path OkBuck to put your generated signing config (relative to your root rootProject dir, no prefix `/`), and `signConfigName` is to set the name of the signing config you want to use.
        ```gradle
            okbuck {
                target "android-23"
                keystoreDir ".okbuck/keystore"
                signConfigName "release"
                overwrite true
                resPackages = [
                    'dummylibrary': 'com.github.piasy.okbuck.example.dummylibrary',
                    'app': 'com.github.piasy.okbuck.example',
                    'common': 'com.github.piasy.okbuck.example.common',
                ]
            }
        ```
        +  but also remember to configure git to ignore your signing secrete
        +  full example could be found in the app module of this repo, [root rootProject build.gradle](build.gradle), [app module build.gradle](app/build.gradle)
    +  `overwrite` is used to control whether overwrite existing buck files;
    +  `resPackages` is used to set Android library module and Android Application module's package name for generated resources (`R` in common cases), you need substitute dummylibrary/app with your own module name, and set the corrosponding package name inside the single quote, which should be the same package name specified in the corrosponding module's AndroidManifest.xml.

4. After executing the okbuck gradle task by `./gradlew okbuck`, you can run `buck install app` now, enjoy your life with buck :)
    +  there are 4 tasks added into your gradle project after you add `apply plugin: 'com.github.piasy.okbuck-gradle-plugin'`, `okbuck`, `okbuckDebug`, `okbuckRelease`, and `okbuckClean`
    +  `okbuckClean` will **remove all** files generated by OkBuck
    +  `okbuck` is the shortcut for `okbuckRelease`
    +  `okbuckDebug` and `okbuckRelease` will make your `debugCompile` and `releaseCompile` dependencies visible in buck's build, including annotation processor

5. It's really only ~~12~~ **10** lines config: ~~step one will only need one line `classpath 'com.github.piasy:okbuck-gradle-plugin:0.0.1'` when OkBuck is sync to jcenter (this will be soon)~~ available now, and then these three steps above only need ~~12~~ **10** lines!

## More job need to be done
OkBuck can only generate the buck config for you, so if your source code is incompitable with buck, you need do more job.

+  Dependency conflict:

    If you see `*** has already been defined` or

    ```java
    BUILD FAILED: //app:bin#dex_merge failed on step dx with an exception:
    Multiple dex files define***
    com.android.dex.DexException: Multiple dex files define ***
    ```

    when you run `buck install app`, you come with dependency confliction, which means multiple modules (let's name them moduleA and moduleB) depend on the same dependency (such as gson), and another module (name it moduleC) depends on moduleA and moduleB, disaster happens. Current work-around is to move all common dependencies into one module, such as moduleA, and make all modules depend on moduleA. This will be addressed in future releases of OkBuck.

+  Dependencies in local libs directory may not be imported correctly. Current work-around is to avoid use local dependencies, but this problem will be definitely addressed soon by OkBuck.

+  References to `R`. Buck is not compitable with libraries like ButterKnife, because R definitions generated by buck are not final, current work-around is change `@Bind`/`@InjectView` to `ButterKnife.findById`, and change `@OnClick` to `setOnClickListener`, etc.

+  And reference to `R` resources from another module may also have problems, should use explicit reference in java code, and also avoid defining resources in different module with the same resources name.

+  versionCode, versionName, targetSdkVersion, minSdkVersion should be set in AndroidManifest.xml rather in build.gradle, example:

    ```xml
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.github.piasy.okbuck.example"
          android:versionCode="1"
          android:versionName="1.0"
        >

        <uses-sdk
                android:targetSdkVersion="23"
                android:minSdkVersion="15"
                />
                ...
    </manifest>
    ```

+  `javax.annotation` dependency: if your module depends on `javax.annotation`, use the `compile` scope rather than `provided` scope.

+  buck can't compile with java 8, so it's incompitable with retrolambda, no more lambda :(

+  Maybe there are more caveats waiting for you, but for the super fast build brought by buck, it's worthwhile.

+  The rest modules in this repo is a full example usage of OkBuck.

## Known caveats
+  Not compitable with `ButterKnife` (buck)
+  Not compitable with `RetroLambda` (buck)
+  `javax.annotation` dependency should be `compile` scope, rather `provided` (OkBuck)
+  Cross module reference on `R` (buck), should use explicit reference in java code, see above
+  Could not refer to design support library's string resource `appbar_scrolling_view_behavior` (buck), that's the specific scenario of the above caveat, quick solution:
  +  define your own string resource: `<string name="my_appbar_scrolling_view_behavior" translatable="false">android.support.design.widget.AppBarLayout$ScrollingViewBehavior</string>`, and use it in your layout file
  +  or use the content directly in your layout file: `app:layout_behavior="android.support.design.widget.AppBarLayout$ScrollingViewBehavior"`
+  (buck & OkBuck) BUCK doesn't support debuggable apk generation easily, current quick solution is add `android:debuggable="true"` to your AndroidManifest.xml, OkBuck will fix this in near future.
+  Multiple application module: OkBuck only support multiple application module with one limitation, they should be set with the same signing config in their module build.gradle, if this bother you, you could split these two application module into two separate project.

## Troubleshooting
If you come with bugs of OkBuck, please [open an issue](https://github.com/Piasy/OkBuck/issues/new), and it's really appreciated to post the output of `./gradle okbuck --stacktrace` at the same time.

## TODO
+  ~~handle apt, provided dependencies~~
+  ~~res reference on aar dependency~~ cross module reference on `R` should use explicit reference (add package name before R) in java code, no issue in xml usage
+  make BUCK's output apk support debug
+  ~~debugCompile/releaseCompile support~~
+  ~~build config~~ only under defaultConfig dsl will work, see below item
+  ~~product flavor support~~ it seems buck doesn't support multi-product flavors, [see](http://stackoverflow.com/a/26001029/3077508), or do I miss something?
+  test/androidTest support
+  proguard support
+  better solution for dependency conflict
+  better solution for local jar dependency
+  more configuration option
+  ~~ci~~
+  ~~code optimization/java doc~~

## Acknowledgement
+  Thanks for Facebook open source [buck](https://github.com/facebook/buck) build system.
+  Thanks for the discussion and help from [promeG](https://github.com/promeG/) during my development.

## Who is using OkBuck?
User | Repo
--- | ---
[Piasy](https://github.com/Piasy) | [AndroidTDDBootStrap](https://github.com/Piasy/AndroidTDDBootStrap)

If you are using OkBuck in your open source project, [send me a<EMAIL_ADDRESS>with your repo url, I'll add your repo in this list.


text:
--------------------------------------------------------------------------------

## Treebank Statistics (UD_Dutch)

This feature is language-specific.
It occurs with 3 different values: `Aux`, `Cop`, `Mod`.
Some words have combined values of the feature; 1 combinations have been observed: `Aux|Cop`.

9649 tokens (5%) have a non-empty value of `VerbType`.
193 types (1%) occur at least once with a non-empty value of `VerbType`.
91 lemmas (0%) occur at least once with a non-empty value of `VerbType`.
The feature is used with 3 part-of-speech tags: [nl-pos/AUX]() (5730; 3% instances), [nl-pos/VERB]() (3908; 2% instances), [nl-pos/X]() (11; 0% instances).

### `AUX`

5730 [nl-pos/AUX]() tokens (36% of all `AUX` tokens) have a non-empty value of `VerbType`.

The most frequent other feature values with which `AUX` and `VerbType` co-occurred: <tt>Subcat=EMPTY</tt> (5730; 100%), <tt>VerbForm=Fin</tt> (5616; 98%), <tt>Aspect=Imp</tt> (5604; 98%), <tt>Mood=Ind</tt> (5604; 98%), <tt>Number=Sing</tt> (4672; 82%), <tt>Tense=Pres</tt> (3861; 67%), <tt>Person=3</tt> (3053; 53%).

`AUX` tokens may have the following values of `VerbType`:

* `Aux,Cop` (5730; 100% of non-empty `VerbType`): is, was, werd, zijn, wordt, worden, waren, werden, ben, heet

`VerbType` seems to be **lexical feature** of `AUX`. 100% lemmas (30) occur only with one value of `VerbType`.

### `VERB`

3908 [nl-pos/VERB]() tokens (25% of all `VERB` tokens) have a non-empty value of `VerbType`.

The most frequent other feature values with which `VERB` and `VerbType` co-occurred: <tt>Subcat=EMPTY</tt> (3908; 100%), <tt>VerbForm=Fin</tt> (3811; 98%), <tt>Aspect=Imp</tt> (3807; 97%), <tt>Mood=Ind</tt> (3807; 97%), <tt>Number=Sing</tt> (2912; 75%), <tt>Tense=Pres</tt> (2824; 72%).

`VERB` tokens may have the following values of `VerbType`:

* `Mod` (3908; 100% of non-empty `VerbType`): heeft, zal, hebben, kan, zou, moet, had, heb, wil, kunnen

`VerbType` seems to be **lexical feature** of `VERB`. 100% lemmas (60) occur only with one value of `VerbType`.

### `X`

11 [nl-pos/X]() tokens (0% of all `X` tokens) have a non-empty value of `VerbType`.

The most frequent other feature values with which `X` and `VerbType` co-occurred: <tt>Number=EMPTY</tt> (10; 91%).

`X` tokens may have the following values of `VerbType`:

* `Aux,Cop` (7; 64% of non-empty `VerbType`): zij_het
* `Mod` (4; 36% of non-empty `VerbType`): laat_staan, Zal_de_Sovjet-Unie_1984_overleven

## Relations with Agreement in `VerbType`

The 10 most frequent relations where parent and child node agree in `VerbType`:
<tt>AUX --[conj]--> AUX</tt> (32; 100%),
<tt>AUX --[parataxis]--> AUX</tt> (12; 100%).

repository: coltekin/docs

branch_name: refs/heads/pages-source

repo_name: coltekin/docs


text:
# dot-properties

JavaScript `parse()` and `stringify()` for `.properties` (`text/x-java-properties`) files as defined in [java.util.Properties](https://docs.oracle.com/javase/9/docs/api/java/util/Properties.html#load-java.io.Reader-).

To install:

```
npm install dot-properties
```

For usage examples, see [below](#example) or take a look through the project's [test suite](tests/).

## API

### `parse(str: string | Line[] | Node[], path?: boolean | string): object`

Parses an input string read from a .properties file into a JavaScript Object

If the second `path` parameter is true, dots `.` in keys will result in a multi-level object (use a string value to customise). If a parent level is directly assigned a value while it also has a child with an assigned value, the parent value will be assigned to its empty string `''` key. Repeated keys will take the last assigned value. Key order is not guaranteed, but is likely to match the order of the input lines.

### `parseLines(str: string, ast?: false): Line[]`

Splits the input string into an array of logical lines; useful if you want to preserve order, comments and/or empty lines while processing. Used internally by `parse()`.

Key-value pairs are `[key, value]` arrays with string values. Escape sequences in keys and values are parsed. Empty lines are included as empty strings `''`, and comments as strings that start with `#` or `!` characters. Leading whitespace is not included.

### `parseLines(str: string, ast: true): Node[]`

Splits the input string into an array of AST nodes; see [the source](./lib/ast.js) for more details.

### `stringify(input: object, options?: StringifyOptions): string`

Stringifies a hierarchical object or an array of lines or nodes to `.properties` format

If `input` is a hierarchical object, keys will consist of the path parts joined by `.` characters. With array input, string values represent blank or comment lines and string arrays are `[key, value]` pairs. Control characters and `\` will be appropriately escaped. If the `latin1` option is not set to false, all non-Latin-1 characters will also be `\u` escaped. Non-empty string lines represent comments, and will have any existing `#` or `!` prefix replaced by the `commentPrefix`.

Output styling is controlled by the second (optional) `options` parameter; by default a spaced `=` separates the key from the value, `\n` is the newline separator, lines are folded at 80 characters (at most, splitting at nice places), with subsequent lines indented by four spaces, and comment lines are prefixed with a `#`. `''` as a key value is considered the default, and set as the value of a key corresponding to its parent object's path:

```js
const defaultOptions = {
  commentPrefix: '# ',  // could also use e.g. '!'
  defaultKey: '',       // YAML 1.1 used '='
  indent: '    ',       // tabs are also valid
  keySep: ' = ',        // should have at most one = or :
  latin1: true,         // default encoding for .properties files
  lineWidth: 80,        // use null to disable
  newline: '\n',        // Windows uses \r\n
  pathSep: '.'          // if non-default, use the same in parse()
}
```

## Example

### `example.properties`

```
# You are reading the ".properties" entry.
! The exclamation mark can also mark text as comments.
# The key characters =, and : should be written with a preceding
# backslash to ensure that they are properly loaded. However, there
# is no need to precede the value characters =, and : by a backslash.
website = https://en.wikipedia.org/
language = English

# The backslash below tells the application to continue reading
# the value onto the next line.
message = Welcome to \
          Wikipedia!

# Add spaces to the key
key\ with\ spaces = This is the value that could be looked up with \
                    the key "key with spaces".

# Unicode
tab : \u0009

# If you want your property to include a backslash, it should be
# escaped by another backslash
path c:\\wiki\\templates
# However, some editors will handle this automatically
```

_Source: [Wikipedia](https://en.wikipedia.org/wiki/.properties)_

### `example.js`

```js
const fs = require('fs')
const { parse, parseLines, stringify } = require('dot-properties')
const src = fs.readFileSync('./example.properties', 'utf8')

const obj = parse(src)
// { website: 'https://en.wikipedia.org/',
//   language: 'English',
//   message: 'Welcome to Wikipedia!',
//   'key with spaces':
//    'This is the value that could be looked up with the key "key with spaces".',
//   tab: '',
//   path: 'c:wiki\templates' }

const str = stringify(obj, { lineWidth: 60 })
console.log(str)
// website = https://en.wikipedia.org/
// language = English
// message = Welcome to Wikipedia!
// key\ with\ spaces = This is the value that could be looked \
//     up with the key "key with spaces".
// tab = \t
// path = c:\\wiki\\templates

const lines = parseLines(src)
// [ '# You are reading the ".properties" entry.',
//   '! The exclamation mark can also mark text as comments.',
//   '# The key characters =, and : should be written with a preceding',
//   '# backslash to ensure that they are properly loaded. However, there',
//   '# is no need to precede the value characters =, and : by a backslash.',
//   [ 'website', 'https://en.wikipedia.org/' ],
//   [ 'language', 'English' ],
//   '',
//   '# The backslash below tells the application to continue reading',
//   '# the value onto the next line.',
//   [ 'message', 'Welcome to Wikipedia!' ],
//   '',
//   '# Add spaces to the key',
//   [ 'key with spaces',
//     'This is the value that could be looked up with the key "key with spaces".' ],
//   '',
//   '# Unicode',
//   [ 'tab', '' ],
//   '',
//   '# If you want your property to include a backslash, it should be',
//   '# escaped by another backslash',
//   [ 'path', 'c:wiki\templates' ],
//   '# However, some editors will handle this automatically' ]

const str2 = stringify(lines.slice(8, 14), { lineWidth: 60 })
console.log(str2)
// # The backslash below tells the application to continue
// # reading
// # the value onto the next line.
// message = Welcome to Wikipedia!
//
// # Add spaces to the key
// key\ with\ spaces = This is the value that could be looked \
//     up with the key "key with spaces".
```

repository: eemeli/dot-properties

repo_name: eemeli/dot-properties


text:
Project Overview

 Problem Statement

Hello!

You have been hired by 'CACT'(Census Analysis and Collection Team) to help with your numpy programming skills. Your major work for today involves census record management and data analysis.

About the Dataset:
The dataset has details of 100 people with the 8 features

### Learnings from the project

 Why solve this project
After completing this project, I have a better grip on working with numpy. In this project, I have applied the following concepts:

Array Appending
Array Slicing
Array Filtering
Array Aggregation

repository: KankshaDhakate/ga-learner-dsmp-repo

repo_name: KankshaDhakate/ga-learner-dsmp-repo


text:
---
layout: post
title: CNSS Certified Network Security Specialist
---

The International Cybersecurity Institute ([ICSI](https://www.icsi.co.uk/)) had an free offer on their Certified Network Security Specialist [course](https://www.icsi.co.uk/courses/icsi-cnss-certified-network-security-specialist-covid-19) due to COVID, so I thought I'd take advantage. I finished the course in about a week and took a bunch of notes which you can find on [SecWiki](https://wiki.zacheller.dev/network-security/isci-cnss-course).

My certificate of completion can be found [here](https://www.credential.net/6c3b5221-26dc-4fa6-9bb6-be4721e52b8c#gs.d7d6vt).


text:
---
layout: default
class: Project
title: -releaserepo* NAME ( ',' NAME ) *
summary: Define the names of the repositories to use for a release
---

You can specify zero or more repository names to use when releasing a project.

The `-releaserepo` instruction aggregates the `-releaserepo` property and all properties that start with `-releaserepo.`. This makes it possible to set release repository names in different places.

If the `-releaserepo` instruction is set to the empty value, then releasing a project does nothing. If the `-releaserepo` instruction is unset, then releasing a project will release it to the first writable repository.

repository: gdams/bnd

gha_language: Java

repo_name: gdams/bnd


text:
# Changelog

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

### [2.2.1](https://github.com/Profiscience/true-case-path/compare/v2.2.0...v2.2.1) (2019-07-24)

### Bug Fixes

* **windows:** Drive letter bug ([1b736b7](https://github.com/Profiscience/true-case-path/commit/1b736b7))

## [2.2.0](https://github.com/Profiscience/true-case-path/compare/v2.0.0...v2.2.0) (2019-07-24)

### Build System

* Add standard-version ([e9b6ab8](https://github.com/Profiscience/true-case-path/commit/e9b6ab8))

### Features

* Add optional basePath argument for selective case-correction ([d5b3d2c](https://github.com/Profiscience/true-case-path/commit/d5b3d2c)), closes [barsh/true-case-path#2](https://github.com/Profiscience/true-case-path/issues/2) [gatsbyjs/gatsby#15876](https://github.com/Profiscience/true-case-path/issues/15876)

## [2.1.0](https://github.com/Profiscience/true-case-path/compare/v2.0.0...v2.1.0) (2019-07-24)

### Build System

* Add standard-version ([e9b6ab8](https://github.com/Profiscience/true-case-path/commit/e9b6ab8))

### Features

* Add optional basePath argument for selective case-correction ([d5b3d2c](https://github.com/Profiscience/true-case-path/commit/d5b3d2c)), closes [barsh/true-case-path#2](https://github.com/Profiscience/true-case-path/issues/2) [gatsbyjs/gatsby#15876](https://github.com/Profiscience/true-case-path/issues/15876)

# 2.0.0 (2019-04-26)

Rewrite, transfer to Profiscience GitHub org, set up CI

### BREAKING CHANGES

- Use named exports instead of exporting sync func by default (was 'module.exports = trueCasePathSync`, now `module.exports = { trueCasePath, trueCasePathSync }`)
- If relying on (undocumented) glob options, those will no longer work
- Drop support for Node <=6

### Features

- Async version of function
- TypeScript definitions

### Bug Fixes

- **Windows:** [Drive letters](https://github.com/barsh/true-case-path/issues/3)
- **Windows:** [Special characters in file path](https://github.com/barsh/true-case-path/issues/5)

repository: Profiscience/true-case-path

repo_name: Profiscience/true-case-path


text:
Welcome to the Trahan Automated Trading platform

This is not even close to complete yet, so don't try to use it. Getting closer now!

Best,
Andrew

In progress:
- Create algorithm that functions for new/incoming data.
- Add fn to export data ranges to text file

To Do:
- Add ema trend indicators
- Determine best way to reference new/current data pulls.
  * Have incoming data draws push to the history db collection?
- Start building authorized client trading structure
- popHist store missing data points to update later
- Fix CTRL-C not quitting all loops
- Add proper threading threading.Event() calls
- Make threads into a class
- Fix print screen overlay to keep ">>>" at bottom
- Build basic UI (HTML/CSS)
- Create proper indexes in Mongo to increase efficiency
- Linear or polynomial regression across l2current data for analysis?
- Remove ticker data draw to mongo? Shouldn't be needed?

Latest:
- Add buy/sell trigger information to output

Completed:
- Repair "updateHist" function
- Build authorized client trading testing structure
- Finish building algorithm
- Updated graph to show buy/sell points
- Start building algorithm for sandbox testing
- Build sandbox client for algorithm testing
- Calculation graph x-axis to NOT seconds
- Add proper notes to code for clarity
- Repaired RSI indicator.
- Fixed minor calcPopulateBulk bug3
- Add calculation graph
- Add RSI calculation.
- calculations are iterating backwards. Flip iteration and reduce data draw.
- Improve efficiency for calcPopulate
- calcPopulate wayyy to slow. Increase Efficiency
- Added basic incomplete data/spotty server handling to popHistory
    (only missed 830/158400 on latest run!!)
- Calcs broken. Fix it!
- Add "updateHist" function
- Clean up L2 notes
- Create proper indexes in Mongo (done for level2current)
- Improve efficiency for lUpdateData
- Add MongoDB launch on startup
- Fix calcPopulate dump to array
- Fix calcPopulation to $push properly
- Start working on DataFunc and building that out!
- Update HistData to loop over selected time range
- Add initial error handling to l2Graph()
- Level 2 works!


text:
---

title: "Interactive reconstructions of cranial 3D implants under MeVisLab as an alternative to commercial planning software - Cranial Defect Datasets"

date: "2017-02-16"

authors: ['admin']

tags:  ['Web Article', 'None', 'figshare']

layout: "post"

---

Publishing date: 2017-02-16

Published on: figshare

summary: Interactive reconstructions of cranial 3D implants under MeVisLab as an alternative to commercial planning software. See https://doi.org/10.1371/journal.pone.0172694 for more details.

authors: Egger et al

link to paper: https://figshare.com/articles/Cranial_Defect_Datasets/4659565

Icons made by catkuro from  www.flaticon.com

repository: amchagas/open-source-toolkit

repo_name: amchagas/open-source-toolkit


text:
# A Cross-Platform Mobile Ridesharing App
 A cross-platform ridesharing app that allows users to sign in, search origin and destination, and select a ride.

* Built the app UI with React Native and implemented navigation between screens, header bars, and tab bars using React Navigation
* Utilized AWS Amplify as backend and connected the app with GraphQL to provide user authentication and realtime database services, including location tracking and data storage of GPS coordinates
* Implemented Google Map APIs to render map and draw routes and to enable autocomplete for the location input

 ## Demo
<image src="./demo/Home-map.gif" height="600"/>
<image src="./demo/Location-search.gif" height="600"/>
<image src="./demo/Route-map.gif" height="600"/>

repository: jessica-q-sun/ridesharing-mobile-app

repo_name: jessica-q-sun/ridesharing-mobile-app


text:
---
layout: page
title: Publication
permalink: /publication/
---

## International Conference & Journal
[1] Song, H., **Kim, M.**, Park, D., and Lee, J., Prestopping: How does Early Stopping can Help Generalization against Label Noise?, In Arxiv: <https://arxiv.org/abs/1911.08059>.

[2] Song, H., **Kim, M.**, Kim, S., and Lee, J., Carpe Diem, Seize the Samples Uncertain “At the Moment” for Adaptive Batch Selection, In Arxiv: <https://arxiv.org/abs/1911.08050>.

[3] Park, D., Song, H., **Kim, M.**, and Lee, J., TRAP: Two-level Regularized Autoencoder-based
Embedding for Power-law Distributed Data, In Proc. The Web Conference 2020 (TheWebConf), Taipei,
Taiwan, Apr. 2020 (top conference, full/oral presentation paper, acceptance rate: 19.2%).

[4] Song, H., **Kim, M.**. and Lee, J., SELFIE: Refurbishing Unclean Samples for Robust Deep Learning, In Proceedings of the 2019 International Conference on Machine Learning (ICML), Long Beach, California, June 2019 (top conference, full paper, acceptance rate: 22.6%).

[5] Song, H., Kim, S., **Kim, M**. and Lee, J., Ada-Boundary: Accelerating the DNN Training via Adaptive Boundary Batch Selection, In OpenReview: <https://openreview.net/forum?id=SyfXKoRqFQ>.

## Domestic Conference & Journal

[1] **Kim, M.**, and Lee, J., Temporal Interval Refinement for Point-of-Interest Recommendation, (SIGDB), vol 34 no. 03 PP. 86 – 98 Dec 2018

[2] Kang, M., **Kim, M.**, Choy, M., and Kim, S., An Experimental Analysis of Static Data Cache Methods for Distributed Processing of Iterative Algorithms, Korea Software Congress, Busan, Korea, September,
2017.

[3] Choy, M., Kang, M., **Kim, M.**, and Kim, S., Exploiting Change Patterns of the Past Context Data on Human Interruptibility Prediction, Korea Software Congress, Busan, Korea, September, 2017

repository: MinSeok-Pons-Kim/MinSeok-Pons-Kim

repo_name: MinSeok-Pons-Kim/MinSeok-Pons-Kim


text:
IDEA 2100
=========

Creativity, Ecology, and Nature Experience
------------------------------------------

### Calendar Description

Students will learn about the interconnected themes of creativity, ecology, sustainability, nature experience, and personal and academic development. They will contextualize their creative and academic inquiries by way of experiences in nature and will broaden their understanding of the relationship between humanity and the natural world.

### Learning Objectives/Outcomes

* Read selected cultural, literary, and historical texts and discuss their origin, development, and contemporary relevance
* Interpret interdisciplinary natural, creative, and spiritual traditions within the context of ecology and sustainability
* Describe the role of natural experience as both an ancient and a current mode of knowledge inquiry
* Evaluate diverse perspectives on the relationship between natural experience and creativity
* Create interdisciplinary projects using strategies developed through experiences in nature

### Content

* Nature and creativity
* Nature as aesthetic experience
* Creative and spiritual inspiration in nature
* Nature as mentor
* Our relationship and lost connection with nature
* Impermanence and cycles (astronomical, biological, climatic, cultural, geological, mythological)
* Learning to listen in the forest
* Embodiment and spirituality in relationship with nature
* Ancestral, Aboriginal, and modern meditation and mindfulness practices in nature
* Deep and social ecology
* Community engagement and natural experience
* Sustainable food

### Essential Skills

#### Creative Thinking and Problem Solving Skills

* Facilitating creative and scientific inquiry, analysis, and evaluation
* Developing problem-solving and synthesis skills in relation to creativity, nature, and the contemporary world
* Practicing the skills required to integrate diverse intellectual and cultural traditions and to develop a critically informed world view
* Developing cross-cultural and interdisciplinary thinking skills
* Developing greater flexibility in contextualizing and synthesizing information

#### Oral Skills

* Participating in discussions on diverse topics
* Asking questions to synthesize and evaluate information
* Practicing active listening
* Developing greater skills in verbal and non-verbal cultural communication

#### Interpersonal Skills

* Participating in a diverse multicultural environment
* Responding with clarity, sensitivity, and cultural awareness
* Collaborating with other students in enhancing the collective learning experience
* Offering and receiving appropriate feedback from other students and the instructor

#### Teamwork and Leadership Skills

* Leading discussions
* Establishing and maintaining cooperative relationships with other students
* Managing self-regulation within a collaborative environment

#### Personal management and entrepreneurial skills

* Taking responsibility for actions and decisions
* Maintaining attitudes of respect and sensitivity toward others
* Taking initiative for project topic selections and completions

#### Writing Skills

* Communicating clearly in writing
* Utilizing effective revision and editing skills

#### Reading and Information Skills

* Practicing the ability to read on a wide range of topics
* Search for and synthesizing ideas from readings
* Using standard reference materials

#### Visual Literacy

* Understanding the link between human aesthetics and nature
* Exploring the visual dimensions of complex and dynamic systems

#### Mathematical Skills

* Exploring the underlying mathematical structures in nature and creativity
* Developing mathematical literacy with regard to the interplay between arts and sciences

#### Intercultural Skills

* Showing sensitivity to the multicultural dimensions of the course materials
* Developing a multicultural point of view with regard to the course content and to contemporary issues influenced by the course content
* Suspending cultural biases so as to fully understand and be informed by the course content

#### Technological Skills

* Using a computer
* Using the World Wide Web to search for and locate information
* Participating in online discussions and content sharing

#### Citizenship and Global Perspective

* Understanding diverse cultural, creative, scientific, and spiritual perspectives
* Participating in a learning environment of global diversity
* Tracing the origins and developments of key creative and scientific movements
* Investigating the diverse and often divergent ways in which cultures understand themselves and their environments

### Learning Activities

* Participating in an integrative learning environment that entails a high level of communication, engagement, motivation, and collaboration
* Experiencing nature in multiple locales in the Vancouver area
* Reading materials from a variety of genres and historical periods
* Researching and developing interdisciplinary projects
* Collaborating with other students on group projects and presentations

### Notes

*Note re engagment project: facilitation activities might include bushcraft, storytelling, sit-spot, nature’s grocery store, nature’s medicine cabinet, the art of animal tracking, mapping, bird language, nature rhythms, mindful walking, five-minute fire, nature photography, nutrient cycles, food webs, etc. All assessments are conducted by learners, faculty, and the lab instructor of the course. (No external assessors are utilized on off-campus trips.)

### Required Texts

Beavington, Lee. Common Plants of Greater Vancouver. 5th ed. Surrey: Kwantlen Print Shop, 2013. Print.

Butala, Sharon. The Perfection of the Morning: an Apprenticesehip in Nature. Toronto: Phyllis Bruce Books, 2005. Print.

Krakauer, Jon. Into the Wild. New York: Anchor, 1997. Print.

### Recommended Texts

Abram, David. The Spell of the Sensuous: Perception and Language in a More-Than-Human World. New York: Vintage, 1997. Print.

Emerson, Ralph Waldo. Nature. Boston: James Munroe, 2006. Web. July 3, 2013

<http://www.archive.org/details/nature29433gut>.

Kroodsma, Donald. The Singing Life of Birds: The Art and Science of Listening to Birdsong. New York: Houghton Mifflin Harcourt, 2007. Print.

Laird, Ross. A Stone's Throw: The Enduring Nature of Myth. Toronto: McClelland and Stewart, 2003. Print.

Louv, Richard. Last Child in the Woods: Saving out Children from Nature-Deficit Disorder. New York: Algonquin, 2005. Print.

Pojar, Jim and Andy Mackinnon. Plants of Coastal British Columbia. Edmonton: Lone Pine, 2005. Print.

Thoreau, Henry David. Walden. Salt Lake City: Project Gutenberg, 2007. Web. July 3, 2013

<http://www.gutenberg.org/ebooks/205>.

Young, Jon, Ellen Haas, and Evan McGown. Coyote's Guide to Connecting with Nature. New York: Owlink Media, 2010. Print.

### Possible field sites

1. Ecology Around the Campus

Explore the webs of connection and consider human impacts (positive and negative).

Science angle:  food webs, invasive species, nutrient cycling, plant ID.
Art angle:  patterns and symmetry, mindfulness.

2. Boundary Bay (Tides and Transitions)

Explore the in-between places, the estuary and intertidal zones.  How do organisms such as the screw snail, lugworm and ghost shrimp survive in this chaotic environment?  How do we cope during times of change?  Consider the influence of the moon.

Science angle:  intertidal zone, biodiversity, tides and lunar cycles.
Art angle:  process and product, transitions.

3. Watershed Park (A Walk/Run in the Woods)

Explore the rich tapestry of the forest.  Listen for birdsong.  Every tree has a story to tell in its rings, leaves and symbolism.  What do they tell us?  Stand still, meditate, walk slowly, go for a run.  Experience yourself in ecological immersion.

Science angle:  dendrochronology, bird language, forest ecology (abiotic and biotic factors, indicator species, nurse logs, adaptations, disturbances, etc).
Art angle:  folklore, mythology, aesthetic experience, creativity.

4. Cougar Creek (The River of Time)

Follow the river and be mindful the The Journey.  Water is central to life, a simple compound of hydrogen and oxygen and yet amazingly unique in its properties to sustain life.

Science angle:  limnology (biological, geological, chemical, and physical characteristics of the river), water cycle, water quality (EPT) index.
Art angle:   artistic inspiration, reflection, finding purpose.

5. Delta Nature Reserve (Bogged Down)

Burns Bog is  a globally unique ecosystem, and one of the largest undeveloped urban wilderness areas in North America.  An immense amount of carbon dioxide is trapped within this raised peat bog.  What happens when we get stuck?  How can we shift things?

Science angle:  unique flora and fauna, carbon cycle, climate change, sustainability.
Art angle:  creativity, inspiration, personal growth.

6. Tynehead Fish Hatchery (Life and Death)

Understand how a hatchery works.  Tynehead is run entirely by volunteers.  Perhaps have the opportunity to participate in an egg take.

Science angle:  life cycle (fish), fish biology, sustainability.
Art angle:  life cycle (human), death and birth in art, connection to food.

7. Vancouver Aquarium

Explore the fantastic marine environments at the aquarium.

Science angle:  marine biology, oceanography, evolution, sustainability.
Art angle:  creative inspiration, colour and texture, movement.

Other sites to consider:  Reifel Bird Sanctuary, Serpentine Fen, Bird Banding @ Colony Farm (Saturdays only), Mountain View Conservation Centre (tours only, have unique animals both native and exotic), Campbell Valley Park, Derby Reach Park, Tynehead Park, farmer’s market, walk along power line trail near Kwantlen, have students propose a site.

BACKUP ACTIVITIES (in case of extreme weather):

1. Visit the biology lab.

2. In class activities (dialogues, reflections, preparing for group presentations, ecology games, meditation, embodiment).

repository: Luciesky/KPU

repo_name: Luciesky/KPU


text:
# Learning_R

A repository that teaches R to my fellow Urban Lab colleagues.

## Repository Structure

| **Folder Name** | **Description** |
| :-------------: | :-------------: |
| [`R`](R/)             | This is where all `.R` scripts will be held that are covered in class are stored. |
| [`resources`](resources/)        | This folder will store resources to help expose folks to the material though a variety of slide decks, blog posts, and other relevant examples. |
| [`raw_data`](raw_data/) | This is where all raw data will be stored. |
| [`write_data`](write_data/) | This is were all manipulated data will be stored. |
| [`visuals`](visuals/) | All visuals created will be stored here. |

## Installing R, Rstudio and Tex

Based on your machine, click on the following links to install the necessary software to follow this tutorial:

* [Mac](https://www.reed.edu/data-at-reed/software/R/r_studio.html)
* [PC](https://www.reed.edu/data-at-reed/software/R/r_studio_pc.html)

## Necessary Packages & Session Info
The R scripts were created using R version 3.5.0 and the desktop version of RStudio 1.1.442.

To ensure you can follow along, please install the following packages:

```R
# install necessary packages
install.packages(pkgs = c("broom", "formattable", "here"
                          , "openxlsx", "RCurl", "rgdal"
                          , "tidyverse"))

# end of script #
```


text:
# termshark-snap
Snap build files for termshark.

## Installation:
```
sudo snap install termshark
sudo snap connect termshark:network-control
sudo snap connect termshark:bluetooth-control
sudo snap connect termshark:firewall-control
sudo snap connect termshark:ppp
sudo snap connect termshark:raw-usb
sudo snap connect termshark:removable-media

```

## Useful links:
- Project home page: [https://termshark.io/](https://termshark.io/)
- Source code: [https://github.com/gcla/termshark](https://github.com/gcla/termshark)

## Acknowledgment:
All credits for this app go to [gcla](https://github.com/gcla) and other contributors.

repository: mharjac/termshark-snap

repo_name: mharjac/termshark-snap


text:
# composer-root-version-action

[![Deploy](https://github.com/ergebnis/composer-root-version-action/workflows/Deploy/badge.svg?branch=main)](https://github.com/ergebnis/composer-root-version-action/actions)
[![Integrate](https://github.com/ergebnis/composer-root-version-action/workflows/Integrate/badge.svg?branch=main)](https://github.com/ergebnis/composer-root-version-action/actions)
[![Prune](https://github.com/ergebnis/composer-root-version-action/workflows/Prune/badge.svg?branch=main)](https://github.com/ergebnis/composer-root-version-action/actions)
[![Release](https://github.com/ergebnis/composer-root-version-action/workflows/Release/badge.svg?branch=main)](https://github.com/ergebnis/composer-root-version-action/actions)
[![Renew](https://github.com/ergebnis/composer-root-version-action/workflows/Renew/badge.svg?branch=main)](https://github.com/ergebnis/composer-root-version-action/actions)

Provides a GitHub Action that sets a [`COMPOSER_ROOT_VERSION`](https://getcomposer.org/doc/03-cli.md#composer-root-version) environment variable from the value of the branch alias defined in `composer.json`.

## Usage

### Inputs

* `branch` - Optional, name of the branch for which we want to retrieve the branch alias. Defaults to `main`.
* `path` - Optional, path in which to look for `composer.json`. Defaults to `'.'`.

```yaml
name: "Integrate"

on:
  pull_request: null
  push:
    branches:
      - "main"

jobs:
  integrate:
    name: "Integrate"

    runs-on: "ubuntu-latest"

    steps:
      - name: "Checkout"
        uses: "actions/checkout@v2"

      - name: "Set COMPOSER_ROOT_VERSION environment variable"
        uses: "ergebnis/composer-root-version-action@main"
        with:
          branch: "main"

      - name: "Install dependencies with composer"
        run: "composer install --no-interaction --no-progress --no-suggest"
```

## Changelog

Please have a look at [`CHANGELOG.md`](CHANGELOG.md).

## Contributing

Please have a look at [`CONTRIBUTING.md`](.github/CONTRIBUTING.md).

## Code of Conduct

Please have a look at [`CODE_OF_CONDUCT.md`](https://github.com/ergebnis/.github/blob/main/CODE_OF_CONDUCT.md).

## License

This package is licensed using the MIT License.

Please have a look at [`LICENSE.md`](LICENSE.md).

## Curious what I am building?

:mailbox_with_mail: [Subscribe to my list](https://localheinz.com/projects/), and I will occasionally send you an email to let you know what I am working on.

repository: ergebnis/composer-root-version-action

gha_language: Shell

repo_name: ergebnis/composer-root-version-action


text:
The insurance guy tells you he needs an updated list of the stolen goods, and surely only to annoy you, he adds, "in reverse alphabetical order".

Given an object with the stolen items, return a new object with the list in reverse alphabetical order.

Examples
{ c: 100, a: 50, b: 10, d: 50 } ➞ { d: 50, c: 100, b: 10, a: 50 }

{ ab: 10, ac: 10, ad: 10 } ➞ { ad: 10, ac: 10, ab: 10 }

{ piano: 5, stereo: 10, suitcase: 1 } ➞ { suitcase: 1, stereo: 10, piano: 5 }

Notes
N/A

repository: redbearin/skill-work

repo_name: redbearin/skill-work


text:
## jaaJBT
This repository contains my building tools (utils, configs, …) for my projects (mainly Cordova) and for now very naive script for syncing these tools across my projects.
### jaaJBT.js
This script provide basic script updating/version checking functionality. Copy this script to your repository and run `node jaaJBT check`. The script loads `package.json` (key _jaaJBT_) and compares regeistered scripts (see example) against __jaaJBT.json in this repository__.

See **[package.json:line27](./package.json#L27)**

### Building tools overview
<details>
<summary>There are overview of my scripts.</summary>

#### aspect_ratio_scss
Pomocné utility pro zachování poměru (např. obrázku) pomocí vlastně `padding-bottom` triku a absolutního pozicování uvnitř relativního rodiče.

Zdroje/inspirace:

   - https://www.vzhurudolu.cz/prirucka/css-pomer-stran

   - https://codepen.io/airen/pen/BZQgRb

[Link to source](bin/aspect_ratio.scss)

#### gulpfile
Common gulpfile for my projects. It dynamically loads configuration from `package.json` and tasks from `./gulp/tasks/`. More description __TBD__.

[Link to source](bin/gulpfile.js)

#### gulp_cleanJSHINT
Utility for using in combination with `gulp_place` (see `filesCleaner` key in argument object).

[Link to source](bin/gulp_cleanJSHINT.js)

#### gulp_place
Returned function 'gulp_place' must be used in gulp.pipe and replacing 'gulp_place' in source files by another files content or eval inputed data (i.e. variables inside gulpfile).

In case of file replacing and situation `^    gulp_place('file');` also spaces and new line (and ';' if writted) is replaced (see 'gulp_place_regex').

The varibale (in case gulp_place('***', 'variable')) is replaced by `'`+***+`'` (means as string)

[Link to source](bin/gulp_place.js)

#### gulp_place_type
Temporaly workaround for type definition for [jaandrle/gulp-place](https://github.com/jaandrle/gulp-place).

[Link to source](bin/gulp_place.type.js)

#### jsonDoc
Naive script for searching JSONs for given files and generating documentations based on templates. More description __TBD__.

[Link to source](bin/jsonDoc.js)

#### gulp_task_config
Gulp task for generating cordovas `config.xml`. More description __TBD__.

[Link to source](bin/task-config.js)

#### gulp_task_css
Gulp task for processing `*.css` and fonts (see line 24). More description __TBD__.

[Link to source](bin/task-css.js)

#### gulp_task_default
Main/default gulp task for serializing others tasks scripts. More description __TBD__.

[Link to source](bin/task-default.js)

#### gulp_task_gradle_fixes
Various fixes for `build.gradle`

There is also possibility to force different current work directory by defining `app.shared.*`. Where `*` must be defined in your `package.json` as `cordova_wrapper_cwd` (don’t forget setting `app_keys_map`)!!!

[Link to source](bin/task-gradle_fixes.js)

#### gulp_task_html
Gulp task for processing `*.html` files in `html/` subdirectory inside `app.directories.src`. More description __TBD__.

[Link to source](bin/task-html.js)

#### gulp_task_img
Gulp task for processing images in `img/` subdirectory inside `app.directories.src`. More description __TBD__.

[Link to source](bin/task-img.js)

#### gulp_task_javascript-libs
Gulp task for processing `*.js` in `js_libs/` subdirectory inside `app.directories.src`. More description __TBD__.

[Link to source](bin/task-javascript-libs.js)

#### gulp_task_javascript
Gulp task for processing `*.js` in `js/` subdirectory inside `app.directories.src`. More description __TBD__.

[Link to source](bin/task-javascript.js)

#### gulp_task_run_cordova_wrapper
Gulp task for running cordova commands (using your own win/mac/linux script defined in `app.shared.cordova_wrapper`).

There is also possibility to force different current work directory by defining `app.shared.*`. Where `*` must be defined in your `package.json` as `cordova_wrapper_cwd` (don’t forget setting `app_keys_map`)!!!

[Link to source](bin/task-run%20c%20!.js)

#### config_main_xml
undefined

[Link to source](bin/config/config.xml)

#### jsconfig
Just `jsconfig.json` config primary for VS Code editor.

[Link to source](bin/non_cordova/jsconfig.json)

#### gulp_task_javascript_lib
Gulp task for processing `*.js` in `app.directories.src`. It also validate non `*.min.js` output files (in `app.directories.bin`). More description __TBD__.

[Link to source](bin/non_cordova/task-javascript.js)

#### config_general_android_params_xml
undefined

[Link to source](bin/config/config_general/android_params.sub.xml)

#### config_general_params_xml
undefined

[Link to source](bin/config/config_general/global_params.sub.xml)

#### config_general_ios_params_xml
undefined

[Link to source](bin/config/config_general/ios_params.sub.xml)
</details>

repository: jaandrle/jaaJBT

repo_name: jaandrle/jaaJBT


text:
---
layout: default
permalink: /standards/terminology/
---
## Standard Terminology

###### LOINC – Logical Observation Identifiers Names and Codes
LOINC was developed and is maintained by the Regenstrief Institute, Inc, a non-profit medical research organization associated with Indiana University. The purpose of LOINC is to facilitate the exchange and pooling of clinical or laboratory results for clinical care, outcomes management, claims attachment, and research by providing a set of universal codes and names. LOINC codes allow users to merge clinical results from many sources into one database for patient care, clinical research, or management.

###### SNOMED CT
SNOMED CT is a clinical terminology and a required standard in interoperability specifications of the US Healthcare Information Technology Standards Panel. The terminology is owned and maintained by the International Health Terminology Standards Development Organisation (IHTSDO), a not-for-profit association. NLM is the United States National Release Center for SNOMED CT.

###### RxNorm
RxNorm provides normalized names for clinical drugs and links its names to many of the drug vocabularies commonly used in pharmacy management and drug interaction software, including
those of First Databank, Micromedex, MediSpan, Gold Standard Drug Database, and Multum. By providing links between these vocabularies, RxNorm can mediate messages between systems not using the same software and vocabulary.


text:
# Braintree Android Google Pay SDK Release Notes

## 3.5.0

* Add support for Elo cards.

## 3.4.0

* Bump `compileSdkVersion` and `targetSdkVersion` to API level 30
* Add `setCountryCode` to `GooglePaymentRequest`

## 3.3.1

* Fix `allowedCardNetworks` in `isReadyToPayRequest` to be uppercased. Thanks @fcastagnozzi.

## 3.3.0

* Add support for Google Pay's `existingPaymentMethodRequired` option

## 3.2.0

* Add support for `isNetworkTokenized`

## 3.1.1

* Fix setting the correct version in metadata

## 3.1.0

* Add check in `requestPayment` to avoid Null Pointer Exception

## 3.0.1

* Resolve issue where optional shipping parameters were treated as if they were required
* Use GooglePayment PayPal client ID

## 3.0.0

* Convert to AndroidX
* Replace AndroidPayConfiguration with GooglePaymentConfiguration

## 2.0.1

* Disable PayPal payment method in Google Payment when the merchant is not able to process PayPal

## 2.0.0

* Add support for Google Pay v2
* Remove support for Google Pay v1
  * To continue using v1, add google-payment:1.0.0 to your build.gradle
  * v1 will remain the defaul for braintree android until the next major version bump
* Replace all UserAddress objects with PostalAddress objects

## 1.0.0

* Enable Google Payment as a separate and independently versioned moduled from Braintree Android
* Supports Google Pay v1
* Represents Google Payment as it was in Braintree Android version 2.18.1