text:
meteor-autocomplete [![Build Status](https://travis-ci.org/mizzao/meteor-autocomplete.svg)](https://travis-ci.org/mizzao/meteor-autocomplete)
===================

Client/server autocompletion designed for Meteor's collections and reactivity.

Check out a demo app at http://autocomplete.meteor.com or the [source](examples/pubsublocal).

Help keep your favorite Meteor packages alive! If you depend on this package in your app and find it useful, consider a donation at [Gittip](https://www.gittip.com/mizzao/) for me (or other Meteor package maintainers).

## What's this do?

Auto-completes typing in text `input`s or `textarea`s from different local or remote Meteor collections when triggered by certain symbols. You've probably seen this when referring to users or issues in a GitHub conversation. For example, you may want to ping a user:

![Autocompleting a user](docs/mention1.png)

...and ask them to look at a certain item:

![Autocompleting something else](docs/mention2.png)

Features:
 - Multiple collection matching with different trigger tokens and fields
 - Fully live and reactive Meteor template rendering of drop-down list items
 - Drop-down can be positioned above or below the text
 - Mouse or keyboard interaction with autocomplete menu
 - Simple token-less autocompletion in an `<input>` element, just like Bootstrap typeahead

Meteor's client-side data availability makes this dynamic, full-fledged autocomplete widget possible. Use it in chat rooms, comments, other messaging systems, or wherever strikes your fancy.

## Usage

Use Meteor to install the package:

```
meteor add mizzao:autocomplete
```

Add a text `input` or `textarea` to a template in one of the following ways, as a Spacebars template or block helper. Pass in any HTML parameters as other arguments to the template:

```
<template name="foo">
    ... stuff
    {{> inputAutocomplete settings=settings id="msg" class="input-xlarge" placeholder="Chat..."}}
    ... more stuff
</template>

<template name="bar">
    ... stuff
    {{#textareaAutocomplete settings=settings id="msg"}}
        {{myStartingText}}
    {{/textareaAutocomplete}}
    ... more stuff
</template>
```

Define a helper for the first argument, like the following example:

```javascript
Template.foo.helpers({
  settings: function() {
    return {
      position: "top",
      limit: 5,
      rules: [
        {
          token: '@',
          collection: Meteor.users,
          field: "username",
          template: Template.userPill
        },
        {
          token: '!',
          collection: Dataset,
          field: "_id",
          options: '',
          matchAll: true,
          filter: { type: "autocomplete" },
          template: Template.dataPiece
        }
      ]
    };
  }
});
```

##### Top Level Options

- `position` (= `top` or `bottom`) specifies if the autocomplete menu should render above or below the cursor. Select based on the placement of your `input`/`textarea` relative to other elements on the page.
- `limit`: Controls how big the autocomplete menu should get.
- `rules`: An array of matching rules for the autocomplete widget, which will be checked in order.

##### Rule Specific Options

- `token`: (optional) What character should trigger this rule. Leave blank for whole-field behavior (see below).
- `collection`: What collection should be used to match for this rule. Must be a `Mongo.Collection` for client-side collections, or a string for remote collections (available in `global` on the server.)
- `subscription`: A custom subscription for server-side search; see below.
- `template`: The template that should be used to render each list item.
- `filter`: (optional) An object that will be merged with the autocomplete selector to limit the results to more specific documents in the collection.
- `sort`: (default `false`) Whether to sort the results before applying the limit. For good performance on large collections, this should be turned on only for server-side searches where an index can be used.
- `noMatchTemplate`: (optional) A template to display when nothing matches. This template can use the [reactive functions on the AutoComplete object](autocomplete-client.coffee) to display a specific message, or be [assigned mouse/keyboard events](http://docs.meteor.com/#eventmaps) for user interaction.

Default matcher arguments: the default behavior is to create a regex against the field to be matched, which will be constructed using the arguments below.

- `field`: The field of the collection that the rule will match against. Can be nested, i.e. `'profile.foo'`.
- `options`: `'i'` (default) to specify the regex matching options.
- `matchAll`: `false` (default) to match only fields starting with the matched string. (see below)

Custom matcher: if this is specified, the *default* matcher arguments will be ignored. (Note that you should still specify `field`.)

- `selector`: a one argument `function(match)` that takes the currently matched token suffix and returns the selector that should be added to the argument to `collection.find` to filter the autocomplete results. (**NOTE**: if you are using `$where`, the selector cannot be serialized to the server).

##### Detecting Selections

Autocomplete triggers jQuery events that can be listened to using Meteor's event maps. The only currently supported event is `autocompleteselect`, which notifies of a selected element. For example:

```
Template.foo.events({
  "autocompleteselect input": function(event, template, doc) {
    console.log("selected ", doc);
  }
});
```

See the example app for more details.

##### Regex Specification and Options

Note that [regular expression searches](http://docs.mongodb.org/manual/reference/operator/query/regex/) can only use an index efficiently when the regular expression has an anchor for the beginning (i.e. `^`) of a string and is a case-sensitive match. Hence, when using case-sensitive matches and string start anchors (i.e. `matchAll: false`) searches can take advantage of server indices in Mongo.

This behavior is demonstrated in the example app.

##### Whole-field (Tokenless) Autocompletion

If you only need to autocomplete over a single collection and want to match the entire field, specify a `rules` array with a single object and omit the `token` argument. The behavior for this is a little different than with tokens; see the [demo](http://autocomplete.meteor.com).

Mixing tokens with tokenless autocompletion is unsupported and will probably result in unexpected behavior.

##### Server-side Autocompletion and Text Search Engines

For security purposes, a default implementation of server-side autocomplete is only provided for insecure collections, to be used while prototyping. In all other applications, write your own publish function with the same arguments as in the [autocomplete-recordset](autocomplete-server.coffee) publication and secure it properly, given that malicious clients can subscribe to this function in ways other than the autocomplete client code would.

Make sure to push documents to the `autocompleteRecords` client-side collection. A convenience function, `Autocomplete.publishCursor`, is provided as an easy way to do this. See the default implementation for an example.

Use of a custom publish function also allows you to:

* use full-text search services outside of Meteor, such as [ElasticSearch](http://www.elasticsearch.org/)
* use [preferential matching](https://github.com/mizzao/meteor-autocomplete/blob/a437c7b464ad9e779da2ca15566a5b91cf603902/autocomplete-server.coffee) for record fields that start with the autocomplete text, rather than contain it anywhere

##### Autocomplete Templates

An autocomplete template is just a normal Meteor template that is passed in the matched document. The template will be passed the entire matched document as a data context, so render list items as fancily as you would like. For example, it's usually helpful to see metadata for matches as in the pictures above.

Records that match the filter text typed after the token render a list of the `template` sorted in ascending order by `field`. For example, if you were matching on `Meteor.users` and you just wanted to display the username, you can do something very simple, and display the same field:

```
<template name="userPill">
    <span class="label">{{username}}</span>
</template>
```

However, you might want to do something a little more fancy and show not only the user, but whether they are online or not (with something like the [user-status](https://github.com/mizzao/meteor-user-status) package. In that case you could do something like the following:

```
<template name="userPill">
    <span class="label {{labelClass}}">{{username}}</span>
</template>
```

and accompanying code:

```javascript
Template.userPill.labelClass = function() {
  if this._id === Meteor.userId()
    return "label-warning"
  else if this.profile.online === true
    return "label-success"
  else
    return ""
}
```

This (using normal Bootstrap classes) will cause the user to show up in orange for him/herself, in green for other users that are online, and in grey otherwise. See [CrowdMapper's templates](https://github.com/mizzao/CrowdMapper/blob/master/client/views/common.html) for other interesting things you may want to do.

##### Examples

For example settings see one of the following:

- [Multi-field example](examples/pubsublocal/client/client.js) (from the app above)
- [Single-field example](examples/pubsublocal/client/single.js) (also from the app above)
- [Autocompleting chatroom example](https://github.com/mizzao/CrowdMapper/blob/master/client/views/chat.coffee)

### Future Work (a.k.a. send pull requests)

- To reduce latency, we could additionally support using `Meteor.methods` to return an array of documents, instead of a subscription, if the client's cache of the collection is assumed to be read-only or if changes don't matter.
- The widget can keep track of a list of ordered document ids for matched items instead of just spitting out the fields (which currently should be unique)
- Could potentially support rendering DOM elements instead of just text. However, this can currently be managed in post-processing code for chat/post functions (like how GitHub does it).

### Credits/Notes

- If you are not using Meteor, you may want to check out [jquery sew](https://github.com/tactivos/jquery-sew), from which this was heavily modified.
- If you need tag autocompletion only (from one collection, and no text), try either the [x-editable smart package](https://github.com/nate-strauser/meteor-x-editable-bootstrap) with Select2 or [jquery-tokenInput](http://loopj.com/jquery-tokeninput/). Those support rendering DOM elements in the input field.

### Main Contributors

- Andrew Mao ([mizzao](https://github.com/mizzao))
- Dan Dascalescu ([dandv](https://github.com/dandv))
- Adam Love ([Neobii](https://github.com/Neobii))

gha_language: CoffeeScript


text:
This repo contains camera filters/scenes created using Babylon.js

How to use:

In OBS Studio create a new Browser element via Sources(+) -> Browser -> Create New.

Change the URL to the path of the source code i.e:

./CameraTest/index.html in this repo becomes:

https://drigax.github.io/BabylonWebCamFX/CameraTest/index.html

These scenes can also be pathed locally, using the absolute path to the scene index.html on disk.

license: MIT

repository: Drigax/BabylonWebcamFX

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Drigax/BabylonWebcamFX


text:
# A Deep Introduction to Julia for Data Science and Scientific Computing

## Introduction

This workshop is put together by Chris Rackauckas as part of the UC Irvine Data Science Initiative. This workshop is made to teach people who are experienced with other scripting languages the relatively new language Julia. Unlike the other Data Science Initiative workshops, this workshop assumes prior knowledge of some form of programming in a language such as Python, R, or MATLAB.

We will start by introducing the basic syntax of the language, and quickly move into the details of how Julia is different from other scripting languages and how to exploit Julia's type system + multiple dispatch to be able to achieve C/Fortran-like performance while maintaining the concise syntax of a scripting language. Large parts of the package ecosystem will be explored and some information on implementation details will be highlighted in order for the participants to learn how to design Julia projects.

The ideal participant is anyone who is interested in Julia. There are many groups of people interested in using Julia. One large fraction come with a strong software development background and C/Fortran knowledge, and are looking to learn Julia as a tool to create packages with enhanced productivity while not losing performance. On the other side, there are users who are interested in the growing package ecosystem of Julia and would like to add Julia to their knowledge-base. And then there's everything in between. One major goal of this workshop is to use Julia's language and syntax to bridge the gap between "package users" and "package developers" in the way that Julia has done.

## Introduction to the Author

Chris is a PhD student in Mathematics from the Mathematical, Computational, and Systems Biology (MCSB) Gateway program and is an active part of the Julia community. He runs the blog, http://www.stochasticlifestyle.com/, where he write tutorials on using the Julia languages covering many topics, such as high-performance and GPGPU computing, package development, and Julia tips. He is part of the JuliaMath and JuliaDiffEq communities for curating the Julia libraries for mathematics and differential equations respectively. Chris is the developer of many Julia packages, the most prominent being [DifferentialEquations.jl](https://github.com/JuliaDiffEq/DifferentialEquations.jl), a Julia library which has become a standard solver for many forms of differential equations.

### Remote Instructors

You are highly encouraged to use the [Julia Gitter chat channel](https://gitter.im/JuliaLang/julia) to ask your Julia-related questions, both during the workshop and after the workshop! There are a few "remote instructors" who will be available through this chat channel at different times throughout the workshop:

- Lyndon White (@oxinabox): University of Western Australia
- Fengyang Wang (@TotalVerb): University of Waterloo
- Ismael Venegas Castelló (@Ismael-VC): Data Analyst at Rich IT
- Seth Bromberger (@sbromberger): Lawrence Livermore National Laboratory

Others will also be available. Please do not be afraid to use this resource!

## Notes Before We Get Started

- Please install some version of IJulia/Jupyter to follow along. I also recommend working through longer problems using the Juno IDE.
- The start of the course will be on developing general performant Julia code. After lunch it will be about the package ecosystem. This understanding of Julia will be useful even for "Julia users" (i.e. non package developers) to use packages effectively, but don't worry we will get to packages.
- Please do the problems/projects at your own pace. Not everyone is expected to complete all of the material in the allotted time. **Some of the problems are supposed to be hard!** Instead, this is supposed to be a resource to introduce you to a large amount of Julia, and the material may take awhile to fully be digested. That's okay!
- During the basic introduction, there will be information that is not included in these notebooks. That is intentional. One major hurdle for learning a language is learning how to find out more about the language. Please use the manual, chatrooms, StackExchange, etc. If these aren't working for you, ask for help.

A good primer for the workshop: https://www.youtube.com/watch?v=JNvMs0j3a4E

## Installation and Setup

To get started, see the [Tooling, Documentation, and Community notebook](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/ToolingDocumentationCommunity).

## Rendered Jupyter Notebooks

### Introduction

- [Tooling, Documentation, and Community](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/ToolingDocumentationCommunity)
- [A Mental Model for Julia](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/JuliaMentalModel)
- [A Very Quick Introduction to Git/Github for Julia Users](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/GithubIntroduction)

### Basics

- [A Basic Introduction to Julia](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/BasicIntroduction)
- [Basic Problems](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/BasicProblems)
- [Intermediate Problems](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/IntermediateProblems)
- [Why Julia?](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/WhyJulia)
- [7 Julia Gotchas and How to Handle Them](http://www.stochasticlifestyle.com/7-julia-gotchas-handle/)

### Detailed Usage: A Peek Into "the Rabbit Hole"

- [Multiple Dispatch Designs: Duck Typing, Hierarchies and Traits](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/DispatchDesigns)
- [Metaprogramming](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/Metaprogramming)
- [Call Overloading](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/CallOverloading)
- [More Details on Arrays and Matrices - How to get Fortran Speeds in Linear Algebra](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/ArraysAndMatrices)
- [Array and Iterator Interfaces](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/ArrayIteratorInterfaces)

### Packages to Explore

This section introduces you to a wide variety of packages for data science and scientific computing in Julia. Many of these pages have example problems for you to have a guided tour through the package basics.

- [Overview of the Package Ecosystem](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/PackageEcosystem)
- [Data Visualization: Plots.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/PlotsJL)
- [Juno, the Julia IDE (Debugging, Progress Bars, etc.): JunoLab](http://docs.junolab.org/latest/)
- [Differential Equations: DifferentialEquations.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/DiffEq)
- [Clustering: Clustering.jl and Distances.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/Clustering)
- [Dimensionality Reduction: MultivariateStats.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/DimensionalityReduction)
- [Mathematical Programming / Optimization: JuMP and Optim.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/Optimization)
- [Solving Nonlinear Equations: NLsolve.jl and Roots.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/NonlinearSolve)
- [Forward-mode Autodifferentiation (with Optimization): ForwardDiff.jl and Optim.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/ForwardDiff)
- [Graph Algorithms and Analysis: LightGraphs.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/Graphs)
- Bioinformatics: Bio.jl
- Deep Learning: KNet.jl, TensorFlow.jl, MXNet.jl, and Flux.jl

### Extra Projects and Problems

- [Using External Languages from Julia (Interop)](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/Interop)
- [Parallelism and HPC](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/HPCJulia)
- [Work in Progress: JuliaML for Machine Learning](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/JuliaML)
- [Package Development, Documentation, and Testing](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/PackageDevelopment)
- Tools for Faster Code: [InplaceOps.jl](https://github.com/simonbyrne/InplaceOps.jl), [CatViews.jl](https://github.com/ahwillia/CatViews.jl), and [VML.jl](https://github.com/JuliaMath/VML.jl)
- Robust Benchmarking: [BenchmarkTools.jl](https://github.com/JuliaCI/BenchmarkTools.jl) and [ProfileView.jl](https://github.com/timholy/ProfileView.jl)

### Experiments

Probe around and understand the following results:

- [Type-Stability Experiment](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/TypeStabilityExperiment)
- [Scoping Experiment](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/ScopingExperiment)

---------------------------
# Problem Answers
---------------------------

#### Answers to the Problems
- [Basic Problem Answers](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/BasicProblemAnswers)
- [Intermediate Problem Answers](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/IntermediateProblemAnswers)
- [Answer to the LightGraphs Problem](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/LightGraphsProblemAnswers)
- [Answer to the Nonlinear Solver Problems](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/NonlinearSolveAnswers)
- [Answer to the DiffEq Problems](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/DiffEqSolutions)
- [Answer to Dimensionality Reduction Problem](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/DimensionalityReductionSolutions)
- [Answer to Clustering Problem](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/ClusteringSolutions)

# Slide Versions of the Pages

### Introduction

- [Tooling, Documentation, and Community](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/ToolingDocumentationCommunity)
- [A Mental Model for Julia](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/JuliaMentalModel)
- [A Very Quick Introduction to Git/Github for Julia Users](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/GithubIntroduction)

### Basics

- [A Basic Introduction to Julia](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/BasicIntroduction)
- [Basic Problems](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/BasicProblems)
- [Intermediate Problems Problems](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/BasicProblems)
- [Why Julia?](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/WhyJulia)

### Detailed Usage: A Peak Into "the Rabbit Hole"

- [Metaprogramming](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/Metaprogramming)
- [Call Overloading](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/CallOverloading)
- [Array and Iterator Interfaces](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/ArrayIteratorInterfaces)
- [More Details on Arrays and Matrices - How to get Fortran Speeds from Linear Algebra](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/ArraysAndMatrices)

### Packages to Explore

- [Overview of the Package Ecosystem](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/PackageEcosystem)
- [Data Visualization: Plots.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/PlotsJL)
- [Differential Equations: DifferentialEquations.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/DiffEq)
- [Clustering: Clustering.jl and Distances.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/Clustering)
- [Dimensionality Reduction: MultivariateStats.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Html/DimensionalityReduction)
- [Mathematical Programming / Optimization: JuMP and Optim.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/Optimization)
- [Solving Nonlinear Equations: NLsolve.jl and Roots.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/NonlinearSolve)
- [Forward-mode Autodifferentiation (with Optimization): ForwardDiff.jl and Optim.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/ForwardDiff)
- [Graph Algorithms and Analysis: LightGraphs.jl](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/Graphs)
- Bioinformatics: Bio.jl
- Deep Learning: KNet.jl, TensorFlow.jl, MXNet.jl, and Flux.jl

### Extra Projects and Problems

- [Using External Languages from Julia (Interop)](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/Interop)
- [Parallelism and HPC](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/HPCJulia)
- [Work in Progress: JuliaML for Machine Learning](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/JuliaML)
- [Package Development, Documentation, and Testing](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/PackageDevelopment)
- Tools for Faster Code: [InplaceOps.jl](https://github.com/simonbyrne/InplaceOps.jl), [CatViews.jl](https://github.com/ahwillia/CatViews.jl), and [VML.jl](https://github.com/JuliaMath/VML.jl)
- Robust Benchmarking: [BenchmarkTools.jl](https://github.com/JuliaCI/BenchmarkTools.jl) and [ProfileView.jl](https://github.com/timholy/ProfileView.jl)

### Experiments

Probe around and understand the following results:

- [Type-Stability Experiment](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/TypeStabilityExperiment)
- [Scoping Experiment](http://ucidatascienceinitiative.github.io/IntroToJulia/Slides/ScopingExperiment)

## How These Were Made

This entire repository is made using Jupyter notebooks using the template from the [JupyterSite](https://github.com/ChrisRackauckas/JupyterSite) repository. To contribute to these materials, see [the Github repository](https://github.com/UCIDataScienceInitiative/IntroToJulia).

repository: BenjaminBorn/IntroToJulia

repo_name: BenjaminBorn/IntroToJulia


text:
forked from joachifm/cl-mechanize

# About
CL-MECHANIZE is a [WWW::Mechanize] work-alike for Common Lisp
implemented as a thin wrapper on top of [Drakma].

This package is still in the early stages of development.
Please read the source before using; do not expect this to do anything useful.

[WWW::Mechanize]: http://search.cpan.org/dist/WWW-Mechanize/lib/WWW/Mechanize.pm
[Drakma]: http://weitz.de/drakma

# Getting
`git clone git://github.com/joachifm/cl-mechanize.git cl-mechanize`

Use [QuickLisp] to easily install the dependencies.

repository: ilook/cl-mechanize

repo_name: ilook/cl-mechanize


text:
---
title: Details
type: Details
---

## Plans

The following plans are built-in to the GCP Service Broker and may be overriden
or disabled by the broker administrator.

  * **basic**: Provides a standalone Redis instance. Use this tier for applications that require a simple Redis cache. Plan ID: `dd1923b6-ac26-4697-83d6-b3a0c05c2c94`.
  * **standard_ha**: Provides a highly available Redis instance that includes automatically enabled cross-zone replication and automatic failover. Use this tier for applications that require high availability for a Redis instance. Plan ID: `41771881-b456-4940-9081-34b6424744c6`.

## Provisioning

**Request Parameters**

 * `authorized_network` _string_ - Optional. The full name of the Google Compute Engine network to which the instance is connected. Default: ``.
 * `memory_size_gb` _string_ - The Redis instance's provisioned capacity in GB. See: https://cloud.google.com/memorystore/pricing for more information. Default: `4`.
    * The string must have at most 10 characters.
    * The string must have at least 1 characters.
    * The string must match the regular expression `[1-9][0-9]*`.
 * `instance_id` _string_ - The name of the Redis instance. Default: `gsb-${counter.next()}-${time.nano()}`.
    * The string must have at most 40 characters.
    * The string must have at least 1 characters.
    * The string must match the regular expression `^[a-z]([-0-9a-z]*[a-z0-9]$)*`.
 * `region` _string_ - The region in which to provision the Redis instance. See: https://cloud.google.com/memorystore/docs/redis/regions for supported regions. Default: `us-east1`.
    * Examples: [us-central1 europe-west2 asia-northeast1 australia-southeast1].
    * The string must match the regular expression `^[a-z]+[-][a-z0-9]+$`.
 * `display_name` _string_ - The human-readable display name of the Redis instance. Default: `${instance_id}`.
    * The string must have at most 30 characters.
    * The string must have at least 4 characters.

## Binding

**Request Parameters**

 * `role` _string_ - The role for the account without the "roles/" prefix. See: https://cloud.google.com/iam/docs/understanding-roles for more details. Default: `redis.viewer`.
    * The value must be one of: [redis.editor redis.viewer].

**Response Parameters**

 * `Email` _string_ - **Required** Email address of the service account.
    * Examples<EMAIL_ADDRESS>    * The string must match the regular expression<EMAIL_ADDRESS> * `Name` _string_ - **Required** The name of the service account.
    * Examples: [pcf-binding-ex312029].
 * `PrivateKeyData` _string_ - **Required** Service account private key data. Base64 encoded JSON.
    * The string must have at least 512 characters.
    * The string must match the regular expression `^[A-Za-z0-9+/]*=*$`.
 * `ProjectId` _string_ - **Required** ID of the project that owns the service account.
    * Examples: [my-project].
    * The string must have at most 30 characters.
    * The string must have at least 6 characters.
    * The string must match the regular expression `^[a-z0-9-]+$`.
 * `UniqueId` _string_ - **Required** Unique and stable ID of the service account.
    * Examples: [112447814736626230844].
 * `redis_version` _string_ - **Required** The version of Redis software.
 * `host` _string_ - **Required** Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
 * `port` _string_ - **Required** The port number of the exposed Redis endpoint.
 * `memory_size_gb` _integer_ - **Required** Redis memory size in GiB.

repository: piotrmiskiewicz/bundles

gha_language: Shell

repo_name: piotrmiskiewicz/bundles


text:
# netbox\_tenancy\_tenant Resource

Manage a tenant within Netbox.

## Example Usage

```hcl
resource "netbox_tenancy_tenant" "tenant_test" {
  name            = "TestTenant"
  slug            = "TestTenant"
  description     = "Tenant created by terraform"
  comments        = "Some test comments"
  tenant_group_id = netbox_tenancy_tenant_group.tenant_group_test.id

  tag {
    name = "tag1"
    slug = "tag1"
  }
}
```

## Argument Reference

The following arguments are supported:
* ``comments`` - (Optional) Comments for this object.
* ``description`` - (Optional) The description for this object.
* ``tenant_group_id`` - (Optional) ID of the group where this object is located.
* ``name`` - (Required) The name for this object.
* ``slug`` - (Required) The slug for this object.

The ``tag`` block supports:
* ``name`` - (Required) Name of the existing tag to associate with this resource.
* ``slug`` - (Required) Slug of the existing tag to associate with this resource.

## Attributes Reference

In addition to the above arguments, the following attributes are exported:
* ``id`` - The id (ref in Netbox) of this object.

license: ISC


text:
# I2C Self-Test Example

(See the README.md file in the upper level 'examples' directory for more information about examples.)

## Overview

This example demonstrates basic usage of I2C driver by running two tasks on I2C bus:

1. Read external I2C sensor, here we take the BH1750 ambient light sensor (GY-30 module) for an example.
2. Use one of the ESP device's I2C port (master mode) to read and write another I2C port (slave mode) in ESP device.

If you have a new I2C application to go (for example, read the temperature data from external sensor with I2C interface), try this as a basic template, then add your own code.

## How to use example

### Hardware Required

To run this example, you should have one ESP development board (e.g. ESP32-WROVER Kit) or ESP core board (e.g. ESP32-DevKitC). Optionally, you can also connect an external sensor. Here we choose the BH1750 just as an example. BH1750 is a digital ambient light sensor. For more information about it, you can read the [datasheet](http://rohmfs.rohm.com/en/products/databook/datasheet/ic/sensor/light/bh1721fvc-e.pdf) of this sensor.

#### Pin Assignment(esp32, esp32s2):

**Note:** The following pin assignments are used by default, you can change these  in the `menuconfig` .

|                           | SDA    | SCL    |
| ------------------------- | ------ | ------ |
| ESP32/ESP32-S2 I2C Master | GPIO18 | GPIO19 |
| ESP32/ESP32-S2 I2C Slave  | GPIO4  | GPIO5  |
| BH1750 Sensor             | SDA    | SCL    |

- slave:
  - GPIO4 is assigned as the data signal of I2C slave port
  - GPIO5 is assigned as the clock signal of I2C slave port
- master:
  - GPIO18 is assigned as the data signal of I2C master port
  - GPIO19 is assigned as the clock signal of I2C master port

- Connection:
  - connect GPIO18 with GPIO4
  - connect GPIO19 with GPIO5
  - connect SDA/SCL of BH1750 sensor with GPIO18/GPIO19

**Note:** It is recommended to add external pull-up resistors for SDA/SCL pins to make the communication more stable, though the driver will enable internal pull-up resistors.

#### Pin Assignment(esp32s3):

**Note:** The following pin assignments are used by default, you can change these  in the `menuconfig` .

|                           | SDA    | SCL    |
| ------------------------- | ------ | ------ |
| ESP32-S3 I2C Master       | GPIO1  | GPIO2  |
| ESP32-S3 I2C Slave        | GPIO4  | GPIO5  |
| BH1750 Sensor             | SDA    | SCL    |

- slave:
  - GPIO4 is assigned as the data signal of I2C slave port
  - GPIO5 is assigned as the clock signal of I2C slave port
- master:
  - GPIO1 is assigned as the data signal of I2C master port
  - GPIO2 is assigned as the clock signal of I2C master port

- Connection:
  - connect GPIO1 with GPIO4
  - connect GPIO2 with GPIO5
  - connect SDA/SCL of BH1750 sensor with GPIO18/GPIO19

**Note:** It is recommended to add external pull-up resistors for SDA/SCL pins to make the communication more stable, though the driver will enable internal pull-up resistors.

#### Pin Assignment(esp32c3, esp32c2, esp32h2):

**Note:** The following pin assignments are used by default, you can change these in the `menuconfig` .

|                                             | SDA    | SCL    |
| ------------------------------------------- | ------ | ------ |
| ESP32-C3/ESP32-C2/ESP32-H2 I2C Master(Slave)| GPIO5  | GPIO6  |
| BH1750 Sensor                               | SDA    | SCL    |

- master:
  - GPIO5 is assigned to the data signal of the I2C master port
  - GPIO6 is assigned to the clock signal of the I2C master port

- Connection:
  - connect SDA/SCL of BH1750 sensor to GPIO5/GPIO6

**Note:** There is only one i2c device on ESP32-C3/ESP32-C2/ESP32-H2, so it is not possible to perform any ESP32/ESP32-S2 self-test example from this repo. However it is possible to test I2C with external devices. If you find anything wrong with your device, please try connecting external pull-up resistors.

### Configure the project

Open the project configuration menu (`idf.py menuconfig`). Then go into `Example Configuration` menu.

- In the `I2C Master` submenu, you can set the pin number of SDA/SCL according to your board. Also you can modify the I2C port number and freauency of the master.
- In the `I2C Slave` submenu, you can set the pin number of SDA/SCL according to your board. Also you can modify the I2C port number and address of the slave.
- In the `BH1750 Sensor` submenu, you can choose the slave address of BH1750 accroding to the pin level of ADDR pin (if the pin level of ADDR is low then the address is `0x23`, otherwise it is `0x5c`). Here you can also control the operation mode of BH1750, each mode has a different resolution and measurement time. For example, in the `One Time L-Resolution` mode, the resolution is 4 Lux and measurement time is typically 16ms (higher resolution means longer measurement time). For more information, you can consult the datasheet of BH1750.

### Build and Flash

Enter `idf.py -p PORT flash monitor` to build, flash and monitor the project.

(To exit the serial monitor, type ``Ctrl-]``.)

See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.

## Example Output

```bash
I (6495) i2c-example: TASK[1] test cnt: 1
*******************
TASK[1]  MASTER READ SENSOR( BH1750 )
*******************
data_h: 01
data_l: d0
sensor val: 386.67 [Lux]
I (6695) i2c-example: TASK[0] test cnt: 2
*******************
TASK[0]  MASTER READ SENSOR( BH1750 )
*******************
data_h: 01
data_l: d0
sensor val: 386.67 [Lux]
*******************
TASK[0]  MASTER READ FROM SLAVE
*******************
====TASK[0] Slave buffer data ====
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f
30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f
40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f
60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f
70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f

====TASK[0] Master read ====
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f
30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f
40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f
60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f
70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f

*******************
TASK[1]  MASTER READ FROM SLAVE
*******************
====TASK[1] Slave buffer data ====
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f
30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f
40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f
60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f
70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f

====TASK[1] Master read ====
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f
30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f
40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f
60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f
70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f

*******************
TASK[0]  MASTER WRITE TO SLAVE
*******************
----TASK[0] Master write ----
0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19
1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29
2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37 38 39
3a 3b 3c 3d 3e 3f 40 41 42 43 44 45 46 47 48 49
4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59
5a 5b 5c 5d 5e 5f 60 61 62 63 64 65 66 67 68 69
6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76 77 78 79
7a 7b 7c 7d 7e 7f 80 81 82 83 84 85 86 87 88 89

----TASK[0] Slave read: [128] bytes ----
0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19
1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29
2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37 38 39
3a 3b 3c 3d 3e 3f 40 41 42 43 44 45 46 47 48 49
4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59
5a 5b 5c 5d 5e 5f 60 61 62 63 64 65 66 67 68 69
6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76 77 78 79
7a 7b 7c 7d 7e 7f 80 81 82 83 84 85 86 87 88 89
```

## Troubleshooting

- BH1750 has two I2C address, which is decided by the voltage level of `ADDR` pin at start up. Make sure to check your schemetic before run this example.

(For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you as soon as possible.)

repository: igrr/esp-idf

gha_language: C

repo_name: igrr/esp-idf


text:
# Scio

[![Build Status](https://github.com/spotify/scio/actions/workflows/tests.yml/badge.svg)](https://github.com/spotify/scio/actions/workflows/tests.yml)
[![codecov.io](https://codecov.io/github/spotify/scio/coverage.svg?branch=master)](https://codecov.io/github/spotify/scio?branch=master)
[![GitHub license](https://img.shields.io/github/license/spotify/scio.svg)](./LICENSE)
[![Maven Central](https://img.shields.io/maven-central/v/com.spotify/scio-core_2.12.svg)](https://maven-badges.herokuapp.com/maven-central/com.spotify/scio-core_2.12)
[![Scaladoc](https://img.shields.io/badge/scaladoc-latest-blue.svg)](https://spotify.github.io/scio/api/com/spotify/scio/index.html)
[![Scala Steward badge](https://img.shields.io/badge/Scala_Steward-helping-brightgreen.svg?style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAQCAMAAAARSr4IAAAAVFBMVEUAAACHjojlOy5NWlrKzcYRKjGFjIbp293YycuLa3pYY2LSqql4f3pCUFTgSjNodYRmcXUsPD/NTTbjRS+2jomhgnzNc223cGvZS0HaSD0XLjbaSjElhIr+AAAAAXRSTlMAQObYZgAAAHlJREFUCNdNyosOwyAIhWHAQS1Vt7a77/3fcxxdmv0xwmckutAR1nkm4ggbyEcg/wWmlGLDAA3oL50xi6fk5ffZ3E2E3QfZDCcCN2YtbEWZt+Drc6u6rlqv7Uk0LdKqqr5rk2UCRXOk0vmQKGfc94nOJyQjouF9H/wCc9gECEYfONoAAAAASUVORK5CYII=)](https://scala-steward.org)

> Ecclesiastical Latin IPA: /ˈʃi.o/, [ˈʃiː.o], [ˈʃi.i̯o]
> Verb: I can, know, understand, have knowledge.

Scio is a Scala API for [Apache Beam](http://beam.incubator.apache.org/) and [Google Cloud Dataflow](https://github.com/GoogleCloudPlatform/DataflowJavaSDK) inspired by [Apache Spark](http://spark.apache.org/) and [Scalding](https://github.com/twitter/scalding).

Scio 0.3.0 and future versions depend on Apache Beam (`org.apache.beam`) while earlier versions depend on Google Cloud Dataflow SDK (`com.google.cloud.dataflow`). See this [page](https://spotify.github.io/scio/Apache-Beam.html) for a list of breaking changes.

# Features

- Scala API close to that of Spark and Scalding core APIs
- Unified batch and streaming programming model
- Fully managed service\*
- Integration with Google Cloud products: Cloud Storage, BigQuery, Pub/Sub, Datastore, Bigtable
- JDBC, [TensorFlow](http://tensorflow.org/) TFRecords, Cassandra, Elasticsearch and Parquet I/O
- Interactive mode with Scio REPL
- Type safe BigQuery
- Integration with [Algebird](https://github.com/twitter/algebird) and [Breeze](https://github.com/scalanlp/breeze)
- Pipeline orchestration with [Scala Futures](http://docs.scala-lang.org/overviews/core/futures.html)
- Distributed cache

\* provided by Google Cloud Dataflow

# Quick Start

Download and install the [Java Development Kit (JDK)](https://adoptopenjdk.net/index.html) version 8.

Install [sbt](https://www.scala-sbt.org/1.x/docs/Setup.html).

Use our [giter8 template](https://github.com/spotify/scio.g8) to quickly create a new Scio job repository:

`sbt new spotify/scio.g8`

Switch to the new repo (default `scio-job`) and build it:

```
cd scio-job
sbt stage
```

Run the included word count example:

`target/universal/stage/bin/scio-job --output=wc`

List result files and inspect content:

```
ls -l wc
cat wc/part-00000-of-00004.txt
```

# Documentation

[Getting Started](https://spotify.github.io/scio/Getting-Started.html) is the best place to start with Scio. If you are new to Apache Beam and distributed data processing, check out the [Beam Programming Guide](https://beam.apache.org/documentation/programming-guide/) first for a detailed explanation of the Beam programming model and concepts. If you have experience with other Scala data processing libraries, check out this comparison between [Scio, Scalding and Spark](https://spotify.github.io/scio/Scio,-Scalding-and-Spark.html).

Example Scio pipelines and tests can be found under [scio-examples](https://github.com/spotify/scio/tree/master/scio-examples/src). A lot of them are direct ports from Beam's Java [examples](https://github.com/apache/beam/tree/master/examples). See this [page](http://spotify.github.io/scio/examples/) for some of them with side-by-side explanation. Also see [Big Data Rosetta Code](https://github.com/spotify/big-data-rosetta-code) for common data processing code snippets in Scio, Scalding and Spark.

- [Scio Docs](https://spotify.github.io/scio/) - main documentation site
- [Scio Scaladocs](http://spotify.github.io/scio/api/) - current API documentation
- [Scio Examples](http://spotify.github.io/scio/examples/) - examples with side-by-side explanation

# Artifacts

Scio includes the following artifacts:

- `scio-core`: core library
- `scio-test`: test utilities, add to your project as a "test" dependency
- `scio-avro`: add-on for Avro, can also be used standalone
- `scio-google-cloud-platform`: add-on for Google Cloud IO's: BigQuery, Bigtable, Pub/Sub, Datastore, Spanner
- `scio-cassandra*`: add-ons for Cassandra
- `scio-elasticsearch*`: add-ons for Elasticsearch
- `scio-extra`: extra utilities for working with collections, Breeze, etc., best effort support
- `scio-jdbc`: add-on for JDBC IO
- `scio-neo4j`: add-on for Neo4J IO
- `scio-parquet`: add-on for Parquet
- `scio-tensorflow`: add-on for TensorFlow TFRecords IO and prediction
- `scio-redis`: add-on for Redis
- `scio-smb`: add-on for Sort Merge Bucket operations
- `scio-repl`: extension of the Scala REPL with Scio specific operations

# License

Copyright 2021 Spotify AB.

Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0

repository: spotify/scio

branch_name: refs/heads/main

gha_language: Scala

repo_name: spotify/scio


text:
---
layout: post
author: Thomas Cashman
title:  "mini2Dx 1.7.3 released"
date:   2018-07-14 18:00:00 +0300
---

mini2Dx 1.7.3 has been released with a fix to using the defer() method multiple times on a UiElement in one update.

To update your existing projects, see the [Updating mini2Dx](https://github.com/mini2Dx/mini2Dx/wiki/Updating-mini2Dx) wiki page.

extension: markdown

gha_language: JavaScript


text:
# Connecting Statement:

This is the end of the part of the story about the beginning of Jesus’ ministry in Galilee. These verses summarize what he did and how the people responded. (See: [[writing-endofstory]])

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
---
layout: page
title: Publications
permalink: /paper/
mathjax: true
---

1. **Rosni, K. V.**, Manish Shukla, Vijayanand Banahatti, and Sachin Lodha. **Consent Recommender System: A Case Study on LinkedIn Settings**, *AAAI Spring Symposium (PAL : Privacy-Enhancing Artificial Intelligence and Language Technologies) 2019, Stanford University - Palo Alto, California.* [PDF](http://ceur-ws.org/Vol-2335/1st_PAL_paper_12.pdf)

2. Vidyadhar Rao, **Rosni K V**, Vineet Padmanabhan. ***Divide and Transfer: Understanding Latent Factors for Recommendation Tasks***, *RecSysKTL Workshop @ ACM RecSys ’17, August 27, 2017, Como, Italy.* [PDF](http://ceur-ws.org/Vol-1887/paper1.pdf)


text:
Link: https://usmanialiq.github.io/team-profile/

Hello Everyone

This project is developed using Material Design Bootstrap 4 (mdbootstrap.com).

It features a grid system which can be used to introduce people. No matter what, you either own a school or college
and want to introduce your faculty or staff or you have a company with skilled employees, it's ideal for you.

An awesome modal pops out when any grid tile is clicked.

Its completely mobile firiendly, highly responsive, easy-to-understand code and a scalable project.

Its a ready to deploy app with minor changes in images, names and related information. Following are the details
to make such changes,
* Change the name of the project by locating 'The Curators of Gold Beach' in 'nav' and then 'a' tags
* To change the 'Visit TheCurators.com', locate 'nav' tags and then on line 36 'a' tags, update the 'href'
* To change the image, locate id="header" and then 'src', make changes
* To change the main header, locate the id="main-header" and replace 'The Curators of Gold Beach' with your text and
same, make changes in the id="support-header" if necessary
* 'div' tags with class="author" would represent a card of a single person
* You can change the image by locating 'src' with 'img' tags
* You can change the name by locating id="h3-author" within 'h3' tags
* You can change the profession by locating id="p-author" with 'p' tags
* You can change the information within the modal by locating data-target="#xyz" within class="div-author", a complete
code with the similar id ( id="xyz" ) would be available at the end of the code, locate it and make changes, it's simple.
* For color changes in navbar, modal, and border of individual grid item, locate this color-code "#9d0227" everywhere
in 'index.html' and 'stylesheet.css' and make changes with your color
* To change the hover effect locate '.div-author:hover{}' in 'stylesheet.css'
* To make changes in the footer, locate 'footer' tag and make changes

repository: usmanialiq/team-profile

repo_name: usmanialiq/team-profile


text:
---
author: Hollie
categories:
  - Dog
  - Puppies
tags:
  - Frenchie
  - Pastis
date: 2019-06-08T07:00:00.000Z
description: Meet Pastis the Frenchie
featured: /img/pastis-hellp-banner.jpg
featuredalt: My Puppie
title: Meet Pastis
type: post
---
Born 20th July 2018 in sunny California, Pastis is our blue fawn French Bulldog!  🐾

{{< fancybox path="https://i.pinimg.com/564x/a8/85/64" file="a88564223af16ed7fe2ec1ca3dda06bb.jpg" caption="" gallery="Baby Photo shoot" >}}
{{< fancybox path="https://i.pinimg.com/originals/40/61/e3" file="4061e318d8486ce196e0eac8723c7a0e.png" gallery="Baby Photo shoot" >}}

We knew right away this little heartbreaker was going to come live with us

{{< fancybox path="https://i.pinimg.com/originals/e5/89/af" file="e589af1b647875d09f0d5447dc1c5698.png" gallery="Bartender" >}}
{{< fancybox path="https://i.pinimg.com/originals/22/d1/8f" file="22d18f6474bf14b71c80dc2b354f03a9.png" gallery="Bartender" >}}

Pastis is named after Ricard Pastis de Marseille, because what's better than alcohol and puppies?

{{< fancybox path="https://i.pinimg.com/564x/17/07/a5/" file="1707a543ad2384f665e6b506a965d676.jpg" gallery="Family" >}}

When he isn't sleeping or eating, Pastis loves to explore and make new friends, all whilst representing the best brands. <a<EMAIL_ADDRESS>target="_top">Let us know</a> if you would like to collaborate!

gha_language: CSS

gha_license_id: MIT


text:
# 2.3.0

The v2.3.0 release has a combination of bug fixes and new features. See below for a complete list of changes.

## Bug fixes and new features

 * Handle ordering of groups in layer list (#732)
 * Add drag and drop to layerlist (#735)
 * Implemented group re-arrangement (#737)
 * Add additional helpers for configuring sources (#741)
 * Make sure we set circle-stroke-width (#744)
 * Fixes to be more in line with Mapbox GL JS / style spec (#746)
 * Added getLayersByGroup func, exposed more dnd API (#745)
 * Add support for setting glyphs (#751)
 * When receiving context, set layer and source version metadata (#752)
 * Add Mapbox GL renderer (#750)
 * Make sure zoom levels are equal (#755)
 * Use correct interpretation for bearing (#759)
 * Use dotenv for Mapbox API key (#761)
 * Add scheme tms support for XYZ raster (#763)
 * Allow the layerlist to pass props to a group class (#766)
 * Add support for ArcGIS REST Identify (#762)
 * Add read support for Esri ArcGIS Rest Feature Services (#767)
 * Mouseposition control (#769)
 * Set map extent in mapinfo reducer (#775)
 * Add scaleline control (#774)
 * If legend depends on sprite, we need to wait for it to load (#783)
 * Call updateSize on map if size changes (#790)
 * Add support for mapbox protocol in TileJSON raster (#786)
 * Allow adding draw and edit styling options (#794)
 * Measure improvements (#798)
 * Replace single time attribute with start and end (#797)
 * Add ability for separate stroke layer for vector legends (#792)
 * Change mapbox gl draw to use a single instance (#803)
 * Add ability to set modes for drawing (#808)
 * Better handle selection and deselection (#804)
 * Implement minZoom and maxZoom (#800)
 * Legend should be visible if layer is invisible (#805)
 * Add an action to fit an extent to the map (#801)
 * Add currentModeOptions to allow passing options to the mode (#811)
 * Fix layer order issue (#814)
 * Async creation of sources (#809)
 * Add actions for adding and removing groups (#815)

### Upgrade notes

#### ol package
The version of the ```ol``` package was updated to 4.6.x.

#### onFeatureDrawn, onFeatureModified, onFeatureSelected
The exisiting callback functions of the Map component, onFeatureDrawn, onFeatureModified and onFeatureSelected now get a collection of features instead of a single feature.
The onFeatureDeselected callback function has been added to deal with deselection of features.

#### Mininum and maximum zoom levels
Metadata has been added to restrict zoom levels on the map, and the zoom-slider component will also respect these (the minZoom and maxZoom props have been removed):

```
  map: {
    metadata: {
      'bnd:minzoom': 10,
      'bnd:maxzoom': 15,
    },
  },
```
You can set the map metadata for instance by using the updateMetadata map action.

The default max zoom level was changed from 24 to 22 as this is more inline with the Mapbox style specification and Mapbox GL JS.

#### Client-side time filtering
The name of the metadata key for filtering time-based datasets on the client has been changed from ```bnd:timeattribute``` to ```bnd:start-time``` and ```bnd:end-time``` where the last one is optional.

repository: ksundeen/sdk

repo_name: ksundeen/sdk


text:
# npmExecute

## Description

Content here is generated from corresponding step, see `vars`.

## Parameters

Content here is generated from corresponding step, see `vars`.

## Step configuration

Content here is generated from corresponding step, see `vars`.

## Exceptions

None

## Examples

```groovy
npmExecute script: this, dockerImage: 'node:8-stretch', npmCommand: 'run build'
```

repository: ravishankarojha/rav-ojha

repo_name: ravishankarojha/rav-ojha


text:
# About

[![GoDoc](https://godoc.org/github.com/martinlindhe/base36?status.svg)](https://godoc.org/github.com/martinlindhe/base36)

Implements Base36 encoding and decoding, which is useful to represent
large integers in a case-insensitive alphanumeric way.

See [example_test.go](example_test.go) for usage

# License

Under [MIT](LICENSE)

repository: BtbN/go-evepraisal

repo_name: BtbN/go-evepraisal


text:
---
title: 6. Rename Test
---

In this test we will check if in-place rename, implemented in the
[Reference Contributor](/tutorials/custom_language_support/reference_contributor.md)
section of the
[Custom Language Support Tutorial](/tutorials/custom_language_support_tutorial.md), works as we expect.

### 6.1. Define input test data

Create a file *RenameTestData.simple*.

```bash
# You are reading the ".properties" entry.
! The exclamation mark can also mark text as comments.
website = http://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
```

Create a file *RenameTestData.java*.

```java
public class Test {
    public static void main(String[] args) {
        System.out.println("simple:website<caret>");
    }
}
```

### 6.2. Create output test data

Create a file *RenameTestDataAfter.simple*.

```bash
# You are reading the ".properties" entry.
! The exclamation mark can also mark text as comments.
websiteUrl = http://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
```

### 6.3. Define a test method

```java
public void testRename() {
    myFixture.configureByFiles("RenameTestData.java", "RenameTestData.simple");
    myFixture.renameElementAtCaret("websiteUrl");
    myFixture.checkResultByFile("RenameTestData.simple", "RenameTestDataAfter.simple", false);
}
```

### 6.4. Run the test

Run the test and make sure it's green.

repository: salious/intellij-sdk-docs

repo_name: salious/intellij-sdk-docs


text:
# Meeting #4
Present: ALL

Date: 4/1/20

Team Name: Solitaire Confinement (Team 52 Pickup)

### Agenda
* Recap what people have done
* Delegate the rest of Design Plan
* Check in on how everyone is doing
* Plan Next Meeting

### Recap what people have done

* Controller
    * Example XML
* Back End
    * APIs for everything
* Front End
    * Wireframe
        * Video of animation
        * Will push soon
    * Interfaces
        * External API changed to fit stuff with back end

### Delegate the rest of Design Plan

* Design: https://hackmd.io/TzI-Q20bT7yeYoIIBieFjA
* Implementation Plan: https://hackmd.io/MR01w47ERHaXbDznA1GGvw
* Use Cases
    * Everyone has to do 8
    * Try not to overlap, nor pick low hanging fruit
* API Examples
    * 5 Use Cases

### Plan Next Meeting
* 8p EDT 4/2/20

gha_language: Java


text:
---
layout: post
title: Learning C as a Second Language
categories: learning c programming
# won't show up in other articles related, doesn't display related
relatedhide: true
---

A moderately comprehensive, no nonsense syntax based guide to programming in C.
Head to the
preface
for more information and to get started.

        1. Preface and History of C

        2. Getting Started

        3. Variables, Strings, and Control Flow


text:
# Unofficial Coinbase Pro API

Unofficial [Coinbase Pro][1] API written in TypeScript and covered by tests.

## Features

- **Typed.** Source code is 100% TypeScript. No need to install external typings.
- **Tested.** Code coverage is at 100%. No surprises when using.
- **Robust.** WebSocket reconnection is built-in. No problems if your Wi-Fi is gone.
- **Easy-to-use.** HTTP requests are easy to customize. HMAC signing and JSON formatting included.

## Installation

```bash
npm install coinbase-pro-node
```

or:

```bash
yarn add coinbase-pro-node
```

## Usage

**Node.js setup**

```javascript
const {CoinbasePro} = require('coinbase-pro-node');

// API Keys can be generated here:
// https://pro.coinbase.com/profile/api
const auth = {
  apiKey: '',
  apiSecret: '',
  passphrase: '',
};
const client = new CoinbasePro(auth);
```

## REST Example

**Query accounts**

```javascript
const tradingAccounts = await client.rest.account.listAccounts();
const message = `You can trade "${tradingAccounts.length}" different pairs.`;
console.log(message);
```

## WebSocket Example

**Event registration**

```javascript
client.on(WebSocketClient.TOPIC.ON_MESSAGE, event => {
  console.log(`Received event of type "${event.type}".`);
});

await client.ws.connect();

client.ws.subscribeToTickers(['BTC-USD', 'ETH-EUR']);
```

## Resources

- [Coinbase Pro API Reference][2]
- [Official Coinbase Pro API](https://github.com/coinbase/coinbase-pro-node)
- [Official Coinbase Pro Trading Toolkit](https://github.com/coinbase/coinbase-pro-trading-toolkit)

## Contributing

Contributions, issues and feature requests are welcome!

Feel free to check [issues page](https://github.com/bennyn/coinbase-pro-node/issues).

**Maintainers**

[![Benny Neugebauer on Stack Exchange][stack_exchange_bennyn_badge]][stack_exchange_bennyn_url]

## License

This project is [MIT](./LICENSE) licensed.

## Show your support

Give a ⭐ if this project helped you!

[1]: https://pro.coinbase.com/
[2]: https://docs.pro.coinbase.com/
[stack_exchange_bennyn_badge]: http://stackexchange.com/users/flair/203782.png?theme=default
[stack_exchange_bennyn_url]: http://stackexchange.com/users/203782/benny-neugebauer?tab=accounts

repository: topless/coinbase-pro-node

repo_name: topless/coinbase-pro-node


text:
# CSC 175 Final Project
Resources for the CSC 175 Final Project.

##Background
The Parkland Bookstore now has a partnership with Best Buy. We are going to build an interactive catalog for the bookstore so that students can see what products they will be able to purchase.

##API
Obtain an API Key from Best Buy [HERE](https://developer.bestbuy.com/documentation/getting-started)

Use Best Buy's API Docs to create your Categories/Products/Products Details pages. It's suggested to use the Recommendations API for getting the top categories and products
- [Recommendations](https://developer.bestbuy.com/documentation/recommendations-api#documentation/recommendations-api-most-popular-viewed)
- [Categories](https://developer.bestbuy.com/documentation/categories-api)
- [Products](https://developer.bestbuy.com/documentation/products-api)

### Query Builder
The Query Builder allows you to craft an API URL that you can then use for an AJAX call. Check it out
- [Query Builder](http://bestbuyapis.github.io/bby-query-builder/#/recommendations)

### Working with Best Buy API Urls
When you use the Best Buy API, you'll find something like `&callback=JSON_CALLBACK` within the URL. This is due to security reasons with making cross-domain AJAX calls. jQuery actually handles this for us already, so since we're using jQuery you can __REMOVE THAT PART FROM THE URL__

##site-starter folder
This contains a starting point for your project if you are in need. __YOU ARE NOT REQUIRED TO USE IT__


text:
irm
===

A place to explore ideas and experiment with WebRTC and Identity (Relationship) Management.

Problem: Every single WebRTC browser client is de facto IoT node. We need dynamic and flexible inter-domain OAuth2 identity pairing system.

Goal: The goal of this framework is to support inter-domain trust management of relationships between publishing and subscribing sides that use IRM.

Task: Evaluate publish subscribe relationship as a layer above OAuth2 and OpenID Connect.

Use cases:
- Access Management for [WebRTC, Identity-Based Encryption Key Generator](https://github.com/igi64/airykey).
- Relationship Management for [WebRTC, Rich Communication Suite](https://github.com/igi64/Drop.Camp).


text:
---
title: "Sharing your work"
order: 73.1
page_id: "sharing"
contextual_links:
  - type: section
    name: "Prerequisites"
  - type: link
    name: "Working with your team"
    url: "/docs/collaborating-in-postman/collaboration-intro/"
  - type: section
    name: "Additional Resources"
  - type: subtitle
    name: "Videos"
  - type: link
    name: "Sharing Postman Collections"
    url: "https://www.youtube.com/watch?v=KMLaibEaf7Y"
  - type: link
    name: "How to Share Postman Collections"
    url: "https://www.youtube.com/watch?v=mVTsK6ZdY6c"
  - type: section
    name: "Next Steps"
  - type: link
    name: "Creating Workspaces"
    url: "/docs/collaborating-in-postman/using-workspaces/creating-workspaces/"

warning: false

---

You can share Postman entities you are working on with collaborators, including collections, APIs, and environments.

> To share a collection run, see [Using the Collection Runner](/docs/running-collections/intro-to-collection-runs/).
>
> To share a collection via embed, use the [Run in Postman](/docs/publishing-your-api/run-in-postman/introduction-run-button/) button.
>
> To share by file, see [Importing and exporting data](/docs/getting-started/importing-and-exporting-data/)

## Contents

* [Sharing to workspaces](#sharing-to-workspaces)
* [Sharing by link](#sharing-by-link)
* [Next steps](#next-steps)

> To share your work via workspaces you will need to be signed in to your [Postman account](/docs/getting-started/postman-account/).

## Sharing to workspaces

When you work in a Postman workspace, any entities you save to the workspace will be visible to other team members who share the workspace—with [varying access levels](/docs/collaborating-in-postman/roles-and-permissions/) depending on your team's configuration.

You can share various Postman entities to workspaces, or move them from one workspace to another, including collections, environments, and APIs.

<img alt="Share collection" src="https://assets.postman.com/postman-docs/share-collection-from-sidebar.jpg" width="600px"/>

To share an entity from Postman, find the entity based on what type it is:

* To share a collection, open it in __Collections__ on the left of Postman and click __Share__, or __Share collection__ in the __...__ menu.
* To share an API, in __APIs__ on the left of Postman, open the __...__ menu and click __Share API__.
* To share an environment, click __Manage environments__ gear icon at the top right of Postman and click __Share__ next to the environment.

![Share environment in browse](https://assets.postman.com/postman-docs/share-environment-in-browse-mode.jpg)

Alternatively find the collection, API, or environment in __Browse__ mode or via your workspace in the [Dashboard](https://app.getpostman.com) and click __Share__ next to it.

You can share collections, APIs, and environments to specific workspaces. _You can additionally share collections via embed and [link](#sharing-by-link) options._

In the share modal, select the workspace you want to share the entity to. Team members in the target workspace will be able to access the entity when you share it there.

[![Share workspace selection](https://assets.postman.com/postman-docs/share-modal-workspace-selection-team.jpg)](https://assets.postman.com/postman-docs/share-modal-workspace-selection-team.jpg)

Toggle the radio button if you also want to remove the entity from its current workspace. If you want to share the collection but keep it in the current workspace as well, click **Share collection**. If you want the collection to be removed from the current workspace after you share it, click **Share collection and remove from this workspace**. The default selection is **Share collection**.

> When you remove a collection from a workspace, all mocks, monitors, and integrations associated with it will also be removed.

Click __Share and Continue__.

[![Share role selection](https://assets.postman.com/postman-docs/share-entity-role-selection.jpg)](https://assets.postman.com/postman-docs/share-entity-role-selection.jpg)

Select view or edit access levels for each collaborator or the workspace as a whole. Click __Save Roles__.

> Refer to [Roles and permissions](/docs/collaborating-in-postman/roles-and-permissions/) for more information on role-based user permissions.

![Adjust roles](https://assets.postman.com/postman-docs/sharing-setting-roles-list.jpg)

> If you want to restore a collection to a workspace it's been removed from, share the collection again. If the collection is deleted and you need to restore access to it, you will need to [recover it](/docs/sending-requests/intro-to-collections/#managing-collections) first.

## Sharing by link

You can share a collection using a link. In the collection share modal, select __Get public link__.

![Share by link](https://assets.postman.com/postman-docs/collection-get-public-link.jpg)

The link is a snapshot of your collection, so click __Update Link__ and copy it for the most up to date version. You can then share it by pasting the copied link. You can also delete the link using the trash button.

> You can manage a complete list of your active collection links from your [Postman profile](https://go.postman.co/me/collections?view=links).

## Next steps

Team members can [request access](/docs/collaborating-in-postman/requesting-access-to-collections/) to collections, environments, and APIs.

For more detail on working with environments as a team, see [Managing environments](/docs/sending-requests/managing-environments/). For more on working with APIs, see [Managing and sharing APIs](/docs/designing-and-developing-your-api/managing-apis/).

repository: carmelag/postman-docs

repo_name: carmelag/postman-docs


text:
# CloudStorage [![Godoc](https://godoc.org/github.com/dcbCIn/CloudStorage?status.svg)](https://godoc.org/github.com/dcbCIn/CloudStorage)
Example system for [MidCloud](https://github.com/dcbCIn/MidCloud) usage, an Adaptive middleware for cloud services, with transparent choice of best cloud.
The basic conceptions are that the message will be sent to the server that has the lower cost to do the task and is available.

## Installation

Install [MidCloud](https://github.com/dcbCIn/MidCloud), and then run this project.

## Usage & Example

Run first the nameServer, then the googleStorage and/or awsStorage, then the clientStorate.

For and examples see the [CloudStorage Godoc](http://godoc.org/github.com/dcbCIn/CloudStorage).

## But Why?!

There exists a long list of middlewares, but MidCloud comes with the proposal of reduce the costs of multi-cloud
applications, and to eradicate any downtime possible.

Can be from a multi-cloud storage (see [CloudStorage](https://github.com/dcbCIn/CloudStorage) project), multi-cloud faas,
or any other you want to create).

repository: dcruzb/CloudStorage

repo_name: dcruzb/CloudStorage


text:
# AngleSharp.Css Contributors

Thanks :heart: to all who contributed to AngleSharp.Css via issues, pull requests, suggestions, and questions.

AngleSharp.Css contains code written by (in order of first pull request / commit):

* [Florian Rappl](https://github.com/FlorianRappl)
* [Michał Kostrzewski](https://github.com/zeaposs)
* [Jochen Kühner](https://github.com/jogibear9988)
* [Tom Hazell](https://github.com/The-Nutty)
* [Michael Ganss](https://github.com/mganss)
* [Gérald Barré](https://github.com/meziantou)
* [Shesh](https://github.com/sheshnathverma)
* [Martin Welsch](https://github.com/MartinWelsch)
* [Jason Nelson](https://github.com/iamcarbon)
* [Bastian Buchholz](https://github.com/campersau)
* [Fraaankes](https://github.com/Fraaankes)
* [Eric Mutta](https://github.com/ericmutta)

Without these awesome people AngleSharp.Css could not exist. Thanks to everyone for your contributions! :beers:

Missing you? Please contact us! Potentially, the simplest way is to file a PR with your name / GitHub profile link added to this file.

branch_name: refs/heads/devel

gha_language: C#


text:
---
title: "home"
bg: white
color: blue
style: center
---
## Black Water Software

My name is David Mitchell and I do freelance work under the business name of [Black Water Software][blackwater]. My speciality is in Ruby and Rails web application development, but I also have experience setting up networks, servers and configuring a number of different software solutions. Lately my focus has shifted to helping small businesses navigate the quagmire of different IT solutions out there and help them get off on the right foot so they don't have to worry about the IT part of their business and instead can focus on serving their customers.

My business is to help others succeed in theirs.

If you are interested in keeping up on content or updates to this website and Black Water Software, please signup for the email list below.

[blackwater]: http://www.blackwatersoftware.com


text:
---
title: "Programme"
workshop: "ppig-2023"
weight: 5
---

> Below is our current working plan for PPIG 2023. Some things might change slightly, but not significantly, and some things are still being confirmed and will be updated as soon as possible. Any questions, please get in touch at<EMAIL_ADDRESS>Looking forward to seeing you all soon!
>
> Note: All times are in CEST (UTC+2, Sweden's timezone)

## Monday, 21st August

|               |                   |
| ------------- | ----------------- |
| 10:00 - 12:00   | Doctoral Consortium (invite-only meeting) |
|               |                   |
| 13:30 - 14:00 | *Fika & registration* |
| 14:00 - 16:00 | *In-person*
 Demos & music
 Bring your own instrument, cool tool or prototype! |
| 16:00 - 18:30 | *Hybrid*
 *Presentation session*  |
|               | Keynote: **Socio-Technical Smells: How Technical Problems Cause Organizational Friction**
 Adam Tornhill, CodeScene |
|               | **A brief history of the human centric study of programming languages**
 Luke Church and Alan Blackwell |
|               | **Overcoming the Mental Set Effect in Programming Problem Solving**
 Agnia Sergeyuk, Sergey Titov, Yaroslav Golubev and Timofey Bryksin |
|               | **Automatic, Suggestive Feedback in Algorithm Visualisation Exercises**
 Artturi Tilanterä |
| 19:00 - onwards | *In-person*
 Vattenhallen & PPIG Dinner |

## Tuesday, 22nd August
|               |                   |
| ------------- | ----------------- |
|  9:30 - 10:00 | *Fika & registration* |
| 10:00 - 12:00 | *In-person*
 Visit to the Lund University Humanities Lab |
| 12:00 - 13:30 | Lunch |
| 14:00 - 16:00 | *In-person*
 Hands-on activities, details TBC |
| 16:00 - 18:00 | *Hybrid*
 *Presentations session* |
|               | Keynote: **Bots in Software Engineering and their impact on development**
 Linda Erlenhov, Chalmers University of Technology |
|               | **How A Data Structure's Linearity Affects Programming and Code Comprehension: The Case of Recursion vs. Iteration**
 Aviad Baron and Dror Feitelson |
|               | **Exploring cognitive waste and cognitive load in software development - a grounded theory**
 Daniel Helgesson |
|               | **Directions in Computational Music**
 Ian Clester |
| 18:30 - onwards | *In-person*
 Museum of Sketches & dinner (optional) |

## Wednesday, 23rd August

### PPIG @ AI Lund: Fika-to-Fika Workshop
This is a workshop in collaboration with AI Lund. For further details, please see [ai.lu.se](https://www.ai.lu.se/2023-08-23).

|               |                   |
| ------------- | ----------------- |
|  9:30 - 10:00 | *Fika & registration* |
| 10:00 - 12:15 | *Hybrid*
 *Morning session*  |
|               | Keynote: **Large Language Models and the Psychology of Programming**
 Clayton Lewis, University of Colorado Boulder |
|               | Interactive session - collaboratively build something creative with LLMs! |
| 12:15 - 13:15 | *Lunch* |
| 13:15 - 15:30 | *Hybrid*
 *Afternoon session* |
|               | **Interactive Narrative Visualization for Learning Markov Decision Process**
 B. Mbuu Mutua and Alan F. Blackwell |
|               | **Participatory prompting: a user-centric research method for eliciting AI assistance opportunities in knowledge workflows**
 Advait Sarkar, Ian Drosos, Rob Deline, Andrew D. Gordon, Carina Negreanu, Sean Rintel, Jack Williams and Benjamin Zorn |
|               | **Prompt Programming for Large Language Models via Mixed Initiative Interaction in a GUI**
 Tanya Morris and Alan Blackwell |
|               | **Back to the future: What do historical perspectives on programming language research tell us about LLMs?**
 Tao Dong and Luke Church |
| 15:30 - 16:00 | *Fika & mingle* |

## Thursday, 24th August
|               |                   |
| ------------- | ----------------- |
| 16:00 - 18:00 | *Online*
 *Presentations session* |
|               | **How Developers Extract Functions: An Experiment**
 Alexey Braver and Dror Feitelson |
|               | **Pronto: Prototyping a Prototyping Tool for Game Mechanic Prototyping**
 Eva Krebs, Tom Beckmann, Leonard Geier, Stefan Ramson and Robert Hirschfeld |
|               | **Integrating Traditional CS Class Activities with Computing for Social Good, Ethics, and Communication and Leadership Skills**
 Renato Cortinovis, Devender Goyal and Luiz Fernando Capretz |
|               | **User-Centric Study and Enhancement of Python Static Code Analysers**
 Steven Chen, Emma Söderberg and Alan McCabe |

## Friday, 25th August
|               |                   |
| ------------- | ----------------- |
| 16:00 - 17:45 | *Online*
 *Presentations session* |
|               | **Parallel Program Comprehension: A Mental Model Approach**
 Leah Bidlake, Eric Aubanel and Daniel Voyer |
|               | **Influencing Code Reading Through Beacons: an Eye-Tracking Study**
 Alan McCabe, Diederick C. Niehorster and Emma Söderberg |
|               | **Towards a definition of the concept of logic of an algorithm**
 Federico Gómez Frois and Sylvia da Rosa |
| 17:45 - 18:00 | *online*
 PPIG Prizes and conference close |

gha_language: HTML


text:
---
layout: sw-tool
title: Sort file and configuration specific custom properties using SOLIDWORKS API
caption: Sort Custom Properties
description: VBA macro to sort file and configuration specific custom properties (in ascending and descending order) using logical order via SOLIDWORKS API
image: sort-custom-properties.svg
labels: [sort, custom properties, bubble]
group: Custom Properties
---
![Sorted custom properties](sorted-custom-properties.png){ width=350 }

This VBA macro sorts the custom properties in a file and all configurations using the logical order with SOLIDWORKS API. Both ascending and descending order can be specified.

Logical order sorts the element as follows. This is an order of files being ordered in Windows File Explorer

* Property1
* Property2
* Property3
* Property12
* Property20
* Property21
* Property30

While alphabetical sort for the above sequence would produce the following result:

* Property1
* Property12
* Property2
* Property20
* Property21
* Property3
* Property30

## Configuration

Macro can be configured by changing the constant values in the macro as follows:

~~~ vb
Const ASCENDING As Boolean = True 'True to sort ascending, False to sort descending
Const REORDER_GENERAL_CUST_PRPS As Boolean = True 'True to sort file specific custom properties, False to skip
Const REORDER_CONF_CUST_PRPS As Boolean = True 'True to sort configuration specific custom properties (for parts and assemblies), False to skip
~~~

Watch [video demonstration](https://youtu.be/jsjN8zNRTuc?t=97)

{% code-snippet { file-name: Macro.vba } %}

repository: tpharber/codestack

repo_name: tpharber/codestack


text:
---
title: 'RSpec'
order: 1
---

Adaptor to use the Allure framework along with the RSpec. See [an
example](https://github.com/allure-examples/allure-rspec-example)
project to take a quick tour.

## What’s new

See the
[releases](https://github.com/allure-framework/allure-rspec/releases)
tab.

## Setup

Add the dependency to your Gemfile. Choose the version carefully:

-   0.5.x - for RSpec2.

-   <= 0.6.7 - for RSpec < 3.2.

-   >= 0.6.9 - for RSpec >= 3.2.

     gem 'allure-rspec'

And then include it in your spec\_helper.rb:

```ruby
RSpec.configure do |c|
  c.include AllureRSpec::Adaptor
end
```

## Advanced options

You can specify the directory where the Allure test results will appear.
By default it would be 'gen/allure-results' within your current
directory.

```ruby
AllureRSpec.configure do |c|
  c.output_dir = "/whatever/you/like" # default: gen/allure-results
  c.clean_dir = false # clean the output directory first? (default: true)
  c.logging_level = Logger::DEBUG # logging level (default: DEBUG)
end
```

## Usage examples

```ruby
describe MySpec, :feature => "Some feature", :severity => :normal do

  before(:step) do |s|
    puts "Before step #{s.current_step}"
  end

  it "should be critical", :story => "First story", :severity => :critical, :testId => 99 do
    "string".should == "string"
  end

  it "should be steps enabled", :story => ["First story", "Second story"], :testId => 31 do |e|

    e.step "step1" do |s|
      s.attach_file "screenshot1", take_screenshot_as_file
    end

    e.step "step2" do
      5.should be > 0
    end

    e.step "step3" do
      0.should == 0
    end

    e.attach_file "screenshot2", take_screenshot_as_file
  end
end
```

repository: allure-framework/allure-docs

repo_name: allure-framework/allure-docs


text:
Homework description
=========
The goal of the lab is to deploy a Tower environment, an openstack environment, and use the openstack workstation as an isolated node to deploy a QA environment from the demo 3 Tier App, then deploy the production environment of the 3 Tier App on amazon and finally configure everything in a workflow in tower.

# Config labs to work togeter

|-- site-setup-prereqs | Config Bastion-Workstation communication to use Workstation as isolated node
|  |
|  |-- setup-workstation
|  |   |-- pre-tasks | Config keys, install python3, git, openstacksdk, /etc/openstack/clouds.yaml
|  |-- osp-setup | Config OSP, create imagenes, flavors, keys, network, security group
|  |   |-- create-image.yml
|  |   |-- create-flavor.yml
|  |   |-- create-keypair.yml
|  |   |-- create-network.yml
|  |   |-- create-sg.yml
|  |-- site-install-isolated-node | Config workstation as isolated node with cloud-user and openstack.pem key

# Config jobs and workflows on tower
|-- site-config-tower.yml
|   |-- config-tower
|   |   |-- pre-config-tower.yml | Copy vars and keys
|   |   |-- post-config-tower.yml | correcto Add project in script, create credentials, inventory, groups, keys
|   |   |-- ec2_dynamic.yml | Create dynamic inventory, tags, groups..
|   |   |-- job_template.yml | Create templates to depoy instances, config vault passwords, deploy 3 tier app
|   |   |-- workflow_template.yml | Create Workflow

# Deploy OSP Instances
|-- site-osp-instances
|   |-- osp-servers | Create Instances, PLAYBOOK BUILD FROM SCRATCH
|   |   |-- var/main.yml | Servers to deploy

# Deploy 3 Tier App
|-- site-3tier-app
|   |-- osp-facts | Get OSP Instances facts and add to inventory
|   |-- base-config | Enable sudo, config repository, install python, git, ansible
|   |-- lb-tier | Config load balancer, PLAYBOOK BUILD FROM SCRATCH
|   |-- app-tier | Config App, PLAYBOOK BUILD FROM SCRATCH
|   |-- db-tier | config DB, PLAYBOOK BUILD FROM SCRATCH

# Test QA Servers
|-- site-smoke-osp | BUILD FROM SCRATCH

# Delete OSP Instances if smoketest fail
|-- site-osp-delete

# Deploy production
- aws_provsion | Change Lab name "Ansible Advanced - Three Tier App"

# Test production
- site-smoketest-aws

Requirements
------------

Any pre-requisites that may not be covered by Ansible itself or the role should be mentioned here. For instance, if the role uses the EC2 module, it may be a good idea to mention in this section that the boto package is required.

Se configuran las varialbes de ambiente con el archivo labrc

>> source ~/labrc

Role Variables
--------------

A description of the settable variables for this role should go here, including any variables that are in defaults/main.yml, vars/main.yml, and any variables that can/should be set via parameters to the role. Any variables that are read from other roles and/or the global scope (ie. hostvars, group vars, etc.) should be mentioned here as well.

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

A list of other roles hosted on Galaxy should go here, plus any details in regards to parameters that may need to be set for other roles, or variables that are used from other roles.

Example Playbook
----------------

Including an example of how to use your role (for instance, with variables passed in as parameters) is always nice for users too:

    - hosts: servers
      roles:
         - { role: username.rolename, x: 42 }

License
-------

BSD

Author Information
------------------

An optional section for the role authors to include contact information, or a website (HTML is not allowed).


text:
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*

- [`<g>`](#g)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

# `<g>`

The `<g>` structural component is used to group multiple components together, to work around the restriction that a JSX expression can only evaluate to a single component. Since it's a virtual component, it doesn't correspond to anything in the DOM.

> **NOTE**: This will soon be changed `<>` to match React 16.2's JSX syntax.

Here's an example that uses the `<g>` tag to insert multiple items into a list at once:

```jsx
import { ObservableArray } from '@twist/core';

@Component
class Employee {
    @Attribute name;
    @Attribute bossName;

    render() {
        return <g>
            <li>{this.name}</li>
            <li>{this.bossName}</li>
        </g>;
    }
}

@Component
export default class MyComponent {

    employees = new ObservableArray([
        {name: 'Alice', bossName: 'Bob'},
        {name: 'Eve', bossName: 'NSA'}
    ]);

    render() {
        return <repeat collection={ this.employees } as={ employee }>
            <Employee name={ employee.name } bossName={ employee.bossName } />
        </repeat>;
    }
}
```

This avoids the need to wrap components in extra `<div>`s, so it keeps the DOM cleaner.

> **NOTE**: One thing to remember is that if you use `<g>` inside an `<svg>`tag, it's always interpreted as the SVG group element.

repository: adobe/twist

repo_name: adobe/twist


text:
# ScriptProxy
A universal proxy for safely connecting TokenScript and IoT devices

## Build Instructions

Linux: ```gradle build```

Windows: ```.\gradlew.bat build```

## Deploy Instructions

```java -jar build/libs/scriptproxy.jar```

## Setup Instructions

By default no setup is required. The SpringBoot server runs on port 8080 and the IoT connection service runs on ports 5000 to 5004. The Web3E bridge library automatically connects to one of these. Multiple ports are used in case there is interference on one of them.
If you wish to change the ports, change the SpringBoot port as normal SpringBoot in the config settings and change the IoT port range in AsyncService.java

For your prototyping usage there is a permanent ScriptProxy set up here for public test use: http://james.lug.org.cn:8080
By default the UDPBridge in Web3E is set to point to this server so no setup is required.


text:
# dotNetRDF Developers Guide

This developers guide is intended for advanced users who want to extend dotNetRDF further and the project developers.  If you are new to dotNetRDF you should start with the [User Guide](/user_guide/index.md) before moving onto this guide.

## SPARQL

The [SPARQL Engine](sparql/sparql_engine.md) section covers non_architectural topics around our SPARQL engine such as optimization and extensions.

* [SPARQL Optimization](sparql/optimization.md)
  * [Implementing Custom Optimizers](sparql/implementing_custom_optimizers.md)
* [SPARQL Extensions](sparql/extensions.md)
* [SPARQL Performance](sparql/performance.md)

## General Topics

This section of the guide covers topics pertaining to advanced functionality of dotNetRDF.

* [Minimizing Memory Usage](/user_guide/howto/minimize_memory_usage.md)
* [Deprecation Policy](deprecation_policy.md)

## Developing for dotNetRDF

This section covers how to contribute to dotNetRDF and is primarily intended for existing/prospective contributors.

* [Compiling](compiling.md)
* [Code Style](code_style.md)
* [Test Environment](test_environment.md)

repository: dotnetrdf/dotnetrdf

gha_license_id: NOASSERTION

repo_name: dotnetrdf/dotnetrdf


text:
# Angular 5 Startup

### Presented for MindIT

---

## Goals

- Construct an Angular 5 application:
    - Navigate between views
    - Perform CRUD operations
    - Consume a REST service
    - Authenticate using an OAuth 2 service
- Become familiar with Web technologies:
    - Typescript & Rx
    - HTML 5
    - Bootstrap 4 visual elements
    - CSS / SASS

---

## Start

```
ng new AngularTraining --style=scss`

ng serve
```

Yup, that simple. Now point your browser to `http//localhost:4200`.

---?code=package.json&lang=json&title=package.json

@[14-30](Build dependencies)
@[32-51](Dev dependencies)

---?code=src/index.html&lang=html&title=index.html

@[5](Title)
@[6](Base)
@[8](Viewport)
@[9](Favicon)
@[12](App root)

---?code=src/app/app.module.ts&lang=typescript&title=app.module.ts

@[1-17](Imports)
@[20-28](Declarations)
@[29-36](Imports)
@[37](Providers)
@[38](Bootstrap)
@[39](Entry components)

---?code=src/app/app.component.ts&lang=typescript&title=app.component.ts

@[4](Selector)
@[5](Template)
@[6](Style)

---?code=src/app/app.component.html&lang=html&title=app.component.html

@[1-21](Navbar)
@[7-20](Collapsible)
@[19](Login)
@[22](Content)

---

## Create the login form

```
ng g c login
```

What this does:

- create folder
- create `login.component.ts`
- create `login.component.html`
- create `login.component.scss`
- create `login.component.spec.ts`
- add component to `app.module.ts`

---?code=src/app/components/login/login.component.html&lang=html&title=login.component.html

@[2-7](Input group)
@[3-5](Font awesome additions)

---

## Routing

- Content components
- Routing module
- Router outlet
- Router link

---?code=src/app/app-routing.module.ts&lang=typescript&title=app-routing.module.ts

@[8-13](The routes)

---?code=src/app/app.component.html&lang=html&title=app.component.html

@[23](Router outlet)
@[9-17](Router links)

---

## Authentication

### When a login is requested

- It should be able to obtain authentication tokens, based on the credentials _we_ used in the REST client
- It should store the authentication token, because it will be used in _every_ request
- It should observe the authentication token expiry
- It should notify an authentication success or error

---

## Authentication (cont'd)

### When a logout is requested

- It should clear the tokens stored
- It should notify the application that there is no longer an authorized user

---

## Authentication (cont'd)

### When a regular request is made

- It should verify that an authentication token is stored
- If an authentication token is not present, but a refresh token is present, a new authentication token should be requested based on the refresh token
- If neither an authentication token, nor a refresh token are stored, the request should be rejected

---?code=src/app/services/auth.service.ts&lang=typescript&title=auth.service.ts

@[18-20](constructor)
@[73-84](Cookie handling)
@[22-33](login)
@[69-71](Error handler)
@[35-49](refresh)
@[51-55](logout)
@[57-67](Check credentials)

---?code=src/app/components/login/login.component.html&lang=html&title=login.component.html

@[1](form element)
@[6,12](ngModel)

---

## REST

- `GET /gidgets` = 'I want a list of gidgets'
- `GET /gidgets/11` = 'I want gidget with ID 11'
- `POST /gidgets [...]` = 'Create a new gidget'
- `PUT /gidgets/11 [...]` = 'Update gidget 11'
- `DELETE /gidget/11` = 'Delete gidget 11'

---

## REST (cont'd)

- `HTTP 2xx` = OK(-ish)
- `HTTP 400` = Bad request
- `HTTP 401` = Not authorized
- `HTTP 404` = Not found
- `HTTP 500` = Server error

---?code=src/app/services/rest.service.ts&lang=typescript&title=rest.service.ts

@[13](constructor)
@[15-31](getList)
@[33-45](getOne)
@[47-59](delete)
@[61-73](update)
@[75-89](create)

---

## CRUD

- Table
- Pagination
- Sort
- Filter / Search
- Delete selected
- Modal editor for New / Selected

---?code=src/app/components/user-list/user-list.component.ts&lang=typescript&title=user-list.component.ts

@[18](Constructor)
@[20-25](Members)
@[27](Communication with Editor)
@[29-35](OnInit)
@[38-45](Load from REST)
@[47-55](Sort)
@[67-70](Create)
@[57-61](Update)
@[63-65](Delete)

---?code=src/app/components/user-list/user-list.component.html&lang=html&title=user-list.component.html

@[1-8](Control bar)
@[2-3](Pagination)
@[4-5](Search)
@[6](Delete)
@[7](New)
@[10-21](Header)
@[13,15,17,19](Font Awesome sort icons logic)
@[22-29](Table body)

---?code=src/app/components/user-editor/user-editor.component.ts&lang=typescript&title=user-editor.component.ts

@[14-15](Constructor)
@[17-21](Inputs)
@[31-39](Form creation)
@[40-56](Form submit)
@[58-61](Visual field validation)

---?code=src/app/components/user-editor/user-editor.component.html&lang=html&title=user-editor.component.html

@[1] (Form binding)
@[11,19](Control reconciliation)

---
## Challenge 1:

- Routing can make use of a `CanLoad` and a [`CanActivate`](https://angular.io/api/router/CanActivate) interface implementation to choose whether or not a user can navigate to a certain page/component. Use this to restrict navigation to `Users` and `Articles` only for logged in users.
- Do not show the links in the menu for anonymous users.
- Use `Router` to navigate to `/` when a route cannot be activated.

---
## Challenge 2:

Build a CRUD for the `Articles` section.

---
## Challenge 3:

Build a 'blog' on the `Home` page.

An anonymous user should see only articles returned under `/public/articles` path of the REST API, while a logged in user should see all the articles.

Order by date descending.

---
## Challenge 4:

```typescript
Dumi.present.subscribe(is=>{
    if(is){
        challenges.next("Build Dumi's component");
    }
});
```

---
## Challenge 5:

Translation challenge:

- Build a service that retrieves key value pairs
- Build a component that switches languages
- Build a [pipe](https://angular.io/guide/pipes) that uses the service to translate items on page

---
## Challenge 6:

Use [ngx-charts](https://github.com/swimlane/ngx-charts) to build the following charts:
- Articles / user (bar)
- Active / Inactive users (pie)
- Admin / Regular users (pie)

repository: deroude/angulartraining

repo_name: deroude/angulartraining


text:
# Rubus amplificatus (Bab.) Lees SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Steele, Handb. field bot. 58. 1847

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Java Glicko Formula Resource

This is a Java implementation of Glicko's original formula, which is used to recalculate player ratings in a formal tournament such as chess. My Glicko resource will calculate a player's new rating and rating deviation (which indicates the rating's reliability) after a series of matches against other players.

[Here](http://www.glicko.net/glicko/glicko.pdf) is Mark Glickman's article about his formula, which explains in some depth how his formula offers improvements over the Elo system. Glickman has a second, further improved formula which he describes in detail [here](http://www.glicko.net/glicko/glicko2.pdf).

This resource is based on Glickman's *first* formula. Resources already exist for his second formula. ([Here](https://github.com/goochjs/glicko2) is one).

## How to Use

Download the jarfile and add it to your build path. New ratings may be calculated on an individual, player-by-player basis, or all at once.

This example uses the same data found in Glickman's article:

```Java
GlickoCompetitor player1 = new GlickoCompetitor("player1", 1500, 200);
GlickoCompetitor player2 = new GlickoCompetitor("player2", 1400, 30);
GlickoCompetitor player3 = new GlickoCompetitor("player3", 1550, 100);
GlickoCompetitor player4 = new GlickoCompetitor("player4", 1700, 300);

GlickoMatchSet matchSet = new GlickoMatchSet();

// the outcome is relative to the first argument (so: player1 beats player2)
matchSet.addMatch(new GlickoMatch(player1, player2, GlickoMatchOutcome.WIN));

// now player1 loses to player3 and player4
matchSet.addMatch(new GlickoMatch(player1, player3, GlickoMatchOutcome.LOSS));
matchSet.addMatch(new GlickoMatch(player1, player4, GlickoMatchOutcome.LOSS));
```

Now that we have created players, created a match set, and added matches involving those players, we can determine the new rating and rating deviation for a specific player. These static methods provide information without updating the player objects:

```Java
System.out.println(GlickoCalculator.getNewRating(player1));
System.out.println(GlickoCalculator.getNewRatingDeviation(player1));
```

We can also update all the player objects at once, and then get the new attributes from the player objects:

```Java
matchSet.assignNewDataToAllCompetitors();

System.out.println(player1.getRating());
System.out.println(player1.getRatingDeviation());
System.out.println(player2.getRating());
System.out.println(player2.getRatingDeviation());
```

Old player objects may be added to a new GlickoMatchSet along with new matches and updated again. Once their ratings and rating deviations have been recalculated, however, their old rating/deviation data will be inaccessible.

# Runtime Concerns

GlickoMatchSet#assignNewDataToAllCompetitors becomes more and more expensive depending primarily on how many matches you have. When evaluating realistic, real-world situations, it should finish in tens of milliseconds or less. However, a tournament with one million matches took around 670ms to run on my system, and any tournament with over 10,000,000 matches may cause time outs. You may want to run this task asynchronously if performance is a concern.

# Expected Improvements

In future updates, I will provide an API and documentation for determining C, a constant in Glickman's formula. Different games should have different values of C depending on how long it takes a player to get "out of practice" at the game.

repository: AJANILOY/glicko-calculator

repo_name: AJANILOY/glicko-calculator