text:
# ![Logo](product/bpz%20logo%20dark.png) boilerplatezero (BPZ)

[![NuGet version (boilerplatezero)](https://img.shields.io/nuget/v/boilerplatezero.svg?style=flat-square)](https://www.nuget.org/packages/boilerplatezero/)
[![MIT License](https://img.shields.io/badge/license-MIT-green.svg?style=flat-square)](/LICENSE)

boilerplatezero (BPZ) is a collection of C# source generators that simplify the code required for common C# patterns.

🔗 Jump to...
- [WPF Dependency Property Generator](#wpf-dependency-property-generator)
- [WPF Routed Event Generator](#wpf-routed-event-generator)
- [🐛 Known Issues List](#-known-issues)

----

## WPF Dependency Property Generator

Dependency properties in WPF are great! However, they do require quite a bit of ceremony in order to define one.

Luckily, dependency properties (and attached properties) always follow the same pattern when implemented.

As such, this kind of boilerplate code is the perfect candidate for a source generator.

The dependency property generator in BPZ works by identifying `DependencyProperty` and `DependencyPropertyKey` fields that are initialized with calls to appropriately-named `Gen` or `GenAttached` methods.

When this happens, the source generator adds private static classes as nested types inside your class & implements the dependency property for you.

Additionally...
- If an appropriate property-changed handler method is found, then it will be used during registration.
- If an appropriate coercion method is found, then it will be used during registration.

🔗 Jump to...
- [👩💻 Write This, Not That](#-write-this-not-that-property-examples)
- [🤖 Generated Code Example](#-generated-code)
- [✨ Features List](#-features)

----

### 👩💻 Write This, Not That: Property Examples

#### 🔧 Dependency Property

```csharp
// Write this (using BPZ):
private static readonly DependencyPropertyKey FooPropertyKey = Gen.Foo<string>();

// Not that (idiomatic implementation):
private static readonly DependencyPropertyKey FooPropertyKey = DependencyProperty.RegisterReadOnly(nameof(Foo), typeof(string), typeof(MyClass), null);
public static readonly DependencyProperty FooProperty = FooPropertyKey.DependencyProperty;
public string Foo
{
    get => (string)this.GetValue(FooProperty);
    private set => this.SetValue(FooPropertyKey, value);
}
```

A more complex example...

```csharp
// Write this (using BPZ):
public static readonly DependencyProperty TextProperty = Gen.Text("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault);
protected virtual void OnTextChanged(string oldText, string newText) { ... }

// Not that (idiomatic implementation):
public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
    nameof(Text), typeof(string), typeof(MyClass),
    new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, TextPropertyChanged));
public string Text
{
    get => (string)this.GetValue(TextProperty);
    set => this.SetValue(TextProperty, value);
}
private static void TextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    ((MyClass)d).OnTextChanged((string)e.OldValue, (string)e.NewValue);
}
protected virtual void OnTextChanged(string oldText, string newText) { ... }
```

#### 🔧 Attached Property

```csharp
// Write this (using BPZ):
private static readonly DependencyPropertyKey BarPropertyKey = GenAttached.Bar<string>();

// Not that (idiomatic implementation):
private static readonly DependencyPropertyKey BarPropertyKey = DependencyProperty.RegisterAttachedReadOnly("Bar", typeof(string), typeof(MyClass), null);
public static readonly DependencyProperty BarProperty = BarPropertyKey.DependencyProperty;
public static string GetBar(DependencyObject d) => (string)d.GetValue(BarProperty);
private static void SetBar(DependencyObject d, string value) => d.SetValue(BarPropertyKey, value);
```

----

### 🤖 Generated Code

Here's an example of hand-written code & the corresponding generated code.

Note that the default value for the dependency property is specified in the user's code & included in the property metadata along with the appropriate property-changed handler.

The documentation comment on `IdPropertyKey` is copied to the generated `Id` property.

```csharp
// 👩💻 Widget.cs
namespace Goodies
{
    public partial class Widget : DependencyObject
    {
        /// <Summary>Gets the ID of this instance.</Summary>
        protected static readonly DependencyPropertyKey IdPropertyKey = Gen.Id("<unset>");

        private static void IdPropertyChanged(Widget self, DependencyPropertyChangedEventArgs e)
        {
            // This method will be used as the property-changed callback during registration!
            // It was selected because...
            // - its name contains the property name, "Id", & ends with "Changed"
            // - it is `static` with return type `void`
            // - the type of parameter 0 is compatible with the owner type
            // - the type of parameter 1 is DependencyPropertyChangedEventArgs
        }
    }
}

// 🤖 Widget.g.cs (actual name may vary)
namespace Goodies
{
    partial class Widget
    {
        public static readonly DependencyProperty IdProperty = IdPropertyKey.DependencyProperty;

        /// <Summary>Gets the ID of this instance.</Summary>
        public string Id
        {
            get => (string)this.GetValue(IdProperty);
            protected set => this.SetValue(IdPropertyKey, value);
        }

        private static partial class Gen
        {
            public static DependencyPropertyKey Id<__T>(__T defaultValue)
            {
                PropertyMetadata metadata = new PropertyMetadata(
                    defaultValue,
                    (d, e) => IdPropertyChanged((Goodies.Widget)d, e),
                    null);
                return DependencyProperty.RegisterReadOnly("Id", typeof(__T), typeof(Widget), metadata);
            }
        }
    }
}
```

----

### ✨ Features

- generates instance properties for dependency properties
- generates static methods for attached properties
- optional default values
- optional FrameworkPropertyMetadataOptions flags
  A flags argument may be specified for the property's FrameworkPropertyMetadata.

  ```csharp
  // 👩💻 user
  public static readonly DependencyProperty TextProperty = Gen.Text<string?>(FrameworkPropertyMetadataOptions.BindsTwoWayByDefault);
  public static readonly DependencyProperty ErrorBrushProperty = GenAttached.ErrorBrush(Brushes.Red, FrameworkPropertyMetadataOptions.Inherits);
  ```

- detects suitable property-changed handlers
  There are 4 options for property-changed handlers.
  If multiple candidates are found, then they are prioritized (from highest to lowest) as shown below (static methods, instance methods, routed events).

  ```csharp
  // 👩💻 user
  public static readonly DependencyProperty SeasonProperty = Gen.Season("autumn");

  // Option 1 - static method, named "*Season*Changed"
  private static void SeasonPropertyChanged(Widget self, DependencyPropertyChangedEventArgs e)
  {
      // This method can be used as the property-changed callback during registration!
      // It is a candidate because...
      // - its name contains the property name, "Season", & ends with "Changed"
      // - it is `static`
      // - return type is `void`
      // - type of parameter 0 is compatible with the owner type
      // - type of parameter 1 is `DependencyPropertyChangedEventArgs`
  }

  // Option 2 - instance method, named "[On]SeasonChanged", 2 parameters
  protected virtual void OnSeasonChanged(string oldSeason, string newSeason)
  {
      // This method can be used as the property-changed callback during registration!
      // It is a candidate because...
      // - its name is "OnSeasonChanged" ("SeasonChanged" is also acceptable)
      // - it is not `static`
      // - return type is `void`
      // - types of parameter 0 & 1 match the property type
      // - names of parameter 0 & 1 start with "old" & "new" (respectively)
  }

  // Option 3 - instance method, named "[On]SeasonChanged", 1 parameter
  protected virtual void OnSeasonChanged(DependencyPropertyChangedEventArgs e)
  {
      // This method can be used as the property-changed callback during registration!
      // It is a candidate because...
      // - its name is "OnSeasonChanged" ("SeasonChanged" is also acceptable)
      // - it is not `static`
      // - return type is `void`
      // - type of parameter 0 is `DependencyPropertyChangedEventArgs`
  }

  // Option 4 - routed event, named "SeasonChangedEvent"
  public static readonly RoutedEvent SeasonChangedEvent = Gen.SeasonChanged<string>();
      // Invoking this event can be used as the property-changed callback during registration!
      // It is a candidate because...
      // - it is a `static readonly RoutedEvent`
      // - it's name is "SeasonChangedEvent"
  ```

- detects suitable value coercion handlers

  ```csharp
  // 👩💻 user
  public static readonly DependencyProperty AgeProperty = Gen.Age(0);
  private static int CoerceAge(Widget self, int baseValue)
  {
      // This method will be used as the value coercion method during registration!
      // It was selected because...
      // - its name is "CoerceAge" (i.e. "Coerce" + the property name)
      // - it is `static`
      // - return type is `object` or matches the property type
      // - type of parameter 0 is compatible with the owner type
      // - type of parameter 1 is `object` or matches the property type
      return (baseValue >= 0) ? baseValue : 0;
  }
  ```

- supports generic owner types
- supports nullable types

  ```csharp
  public static readonly DependencyProperty IsCheckedProperty = Gen.IsChecked<bool?>(false);
  public static readonly DependencyProperty NameProperty = Gen.Name<string?>();
  ```

- access modifiers are preserved on generated members
- documentation is preserved (for dependency properties) on generated members
- generates dependency property fields for read-only properties (if necessary)

  ```csharp
  // 👩💻 user
  // Instance field `FooProperty` is defined, so it will not be generated.
  // Access modifiers for generated get/set of the `Foo` instance property will match the property & key.
  private static readonly DependencyPropertyKey FooPropertyKey = GenAttached.Foo(3.14f);
  protected static readonly DependencyProperty FooProperty = FooPropertyKey.DependencyProperty;

  // Instance field `BarProperty` is not defined, so it will be generated.
  private static readonly DependencyPropertyKey BarPropertyKey = Gen.Bar<Guid>();

  // 🤖 generated
  protected float Foo
  {
      get => (float)this.GetValue(FooProperty);
      private set => this.SetValue(FooPropertyKey, value);
  }

  public static readonly DependencyProperty BarProperty = BarPropertyKey.DependencyProperty;
  public System.Guid Bar
  {
      get => (System.Guid)this.GetValue(BarProperty);
      private set => this.SetValue(BarPropertyKey, value);
  }
  ```

- attached properties may constrain their target type by specifying a generic type argument on GenAttached

  ```csharp
  // 👩💻 user
  // Attached property `Standard` may be used with any dependency object.
  public static readonly DependencyProperty StandardProperty = GenAttached.Standard("🍕");

  // Attached property `IsFancy` may only be used with objects of type <see cref="Widget"/>.
  public static readonly DependencyProperty IsFancyProperty = GenAttached<Goodies.Widget>.IsFancy(true);

  // 🤖 generated
  public static string GetStandard(DependencyObject d) => (string)d.GetValue(StandardProperty);
  public static void SetStandard(DependencyObject d, string value) => d.SetValue(StandardProperty, value);

  public static bool GetIsFancy(Goodies.Widget d) => (bool)d.GetValue(IsFancyProperty);
  public static void SetIsFancy(Goodies.Widget d, bool value) => d.SetValue(IsFancyProperty, value);
  ```

----

## WPF Routed Event Generator

Similar to dependency properties, routed events always use the same pattern when implemented correctly.

The routed event generator in BPZ works by identifying `RoutedEvent` fields that are initialized with calls to appropriately-named `Gen` or `GenAttached` methods.

When this happens, the source generator adds private static classes as nested types inside your class & implements the routed event for you.

🔗 Jump to...
- [👩💻 Write This, Not That](#-write-this-not-that-event-examples)
- [✨ Features List](#-features-1)

----

### 👩💻 Write This, Not That: Event Examples

#### ⚡ Routed Event

```csharp
// Write this (using BPZ):
public static readonly RoutedEvent FooChangedEvent = Gen.FooChanged<string>();

// Not that (idiomatic implementation):
public static readonly RoutedEvent FooChangedEvent = EventManager.RegisterRoutedEvent(nameof(FooChanged), RoutingStrategy.Direct, typeof(RoutedPropertyChangedEventHandler<string>), typeof(MyClass));
public event RoutedPropertyChangedEventHandler<string> FooChanged
{
    add => this.AddHandler(FooChangedEvent, value);
    remove => this.RemoveHandler(FooChangedEvent, value);
}
```

#### ⚡ Attached Event

```csharp
// Write this (using BPZ):
public static readonly RoutedEvent ThingUpdatedEvent = GenAttached.ThingUpdatedChanged(RoutingStrategy.Bubble);

// Not that (idiomatic implementation):
public static readonly RoutedEvent ThingUpdatedEvent = EventManager.RegisterRoutedEvent(nameof(BarChanged), RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(MyClass));
public static void AddThingUpdatedHandler(DependencyObject d, RoutedEventHandler handler) => (d as UIElement)?.AddHandler(BarChangedEvent, handler);
public static void RemoveThingUpdatedHandler(DependencyObject d, RoutedEventHandler handler) => (d as UIElement)?.RemoveHandler(BarChangedEvent, handler);
```

----

### ✨ Features

- generates instance events for routed events
- generates static methods for attached events
- handler type may be specified via generic type argument on the generator method (e.g. `Gen.FooChanged<RoutedPropertyChangedEventHandler<string>()`)
- handler type is optional (default is `RoutedEventHandler`)
- handler types that are **not** delegates (e.g. `Gen.FooChanged<string>()`) are treated as `RoutedPropertyChangedEventHandler<T>` with the specified type
- routing strategy may be specified via generator method argument (e.g. `Gen.ThingUpdated(RoutingStrategy.Bubble)`)
- routing strategy is optional (default is `RoutingStrategy.Direct`)
- supports generic owner types
- access modifiers are preserved on generated members
- documentation is preserved (for routed events) on generated members
- attached events may constrain their target type by specifying a generic type argument on `GenAttached`

----

### 🐛 Known Issues

related: Source Generator support for WPF project blocked? [#3404](https://github.com/dotnet/wpf/issues/3404)
- fix / workaround: use this in project file
  ```xml
  <IncludePackageReferencesDuringMarkupCompilation>true</IncludePackageReferencesDuringMarkupCompilation>
  ```

repository: shmuelie/boilerplatezero

repo_name: shmuelie/boilerplatezero


text:
# Snow Crash Development Tools

## Gyp
Snow Crash uses (bundled) [Gyp](https://gyp.gsrc.io/) build automation tool to
generate its Makefiles.

### Actual Bundled Version
[**SHA d84fed246cd42612c31a56a897e2d032e254a58a**](https://chromium.googlesource.com/external/gyp/+/d84fed246cd42612c31a56a897e2d032e254a58a)

### Update
1. Download the latest stable version of Gyp from its [repository](https://chromium.googlesource.com/external/gyp/+/refs/heads/master)

2. Remove unnecessary files:

	```sh
	$ rm -rf .svn
	$ rm -rf test
	```

3. Update bundled version in this README

### More info
See [Gyp Hello World](https://github.com/springmeyer/hello-gyp) for a primer on
using Gyp.

license: MIT

repository: darkcl/snowcrash

branch_name: refs/heads/master

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive

repo_name: darkcl/snowcrash


text:
# Range
## Min / max
Defines the minimum and maximum values to be displayed on the meter bars. This does not
affect the text readings above the bars.

## Ref
<link type="document" target="Controls">Controls</link>
the position of the reference value on the display. This does not affect the meter values per
se, it is a cosmetic setting only.


text:
# Log Sensor Data to Localhost #
## An interactive questionnaire and sensory data logger that feeds data outside FitBit environment ##
A fitbit app that logs barometric and heartrate sensor data and the answers from an interactive questionnaire to a log file via a PHP server on localhost.

### Companion App ###
##### companion/index.js ######
Currently contains configurable settings for enabling/disabling Heart Rate Sensor and the Barometer.
* Comprises of `messaging` event listners to send information to the Watch App and pull the JSON objects from the watch.
* On receiving a message from the watch App, `postData` gets triggered which uses `fetch()` API to POST to `get_data.php` on the php server (currently hardcoded as `http://localhost:8888/get_data.php`).
* Data is logged in `localhost/php_log`.

### Watch App ###
##### app/index.js #####
###### EventListeners ######
* [yes/no]Button: Listens to the questionnaire's `yes` buttons actions.
** if questionnaireCounter (tally of how many questions has already been presented) is 2 i.e. the final value, the returned JSON string will be stored in finalJSON
** with no being the first option of the questionnaire i.e. `questionnaireCounter == 0`, the questionnaire will hide.
* Sensor Monitoring
** Listens to messages being sent from the Companion App, namely for initial settings configurations and sensor on/off toggles
** Triggers `displayedSensors` that will dynamically reposition the visible sensors on the GUI when hidden/unhidden
* exit
** Triggers the action of sending data back to Companion App.
** Stringifies `finalJSON`
** exits the app
###### Functions ######
* `displayedSensors`: Dynamic layout of sensor elements in the gui.

##### app/appGUI.js #####
Controls the dynamic layout and positioning of displayed sensor values and timer

##### app/textSequence.js #####
Handles the questionnaire information, generates the JSON object that eventually gets pushed to Companion App

##### timeControl.js #####
* Exports a milliseconds to seconds (Type: String??) function
* Get current time in "YYYY-MM-DD hh24:mi:ss" format.


text:
# Nasa

[![travis-ci](https://travis-ci.org/pdai1y/nasa.svg?branch=master)](https://travis-ci.org/pdai1y/nasa) [![Coverage Status](https://coveralls.io/repos/github/pdai1y/nasa/badge.svg?branch=master)](https://coveralls.io/github/pdai1y/nasa?branch=master)

Ruby Wrapper for the various NASA API Services.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'nasa'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install nasa

## Usage

You can check the documentation [here](https://pdai1y.github.io/nasa)

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/pdai1y/nasa.

## License

The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

gha_language: Ruby


text:
---
layout: post
title: In Loving Memory of Kenneth Earle Collins
categories:
  - lifestyle
---

#### Kenneth Earle Collins, 66, of Chesapeake, Virginia, passed away January 5th, 2013.

My father, known to his friends and family as Kenny, was born in Logan, West Virginia and was the son of the late Edgar and Frances Collins. He was a retired Master Deputy with the Chesapeake Sheriff's Department. Kenny is survived by his beloved wife of 7 years, Lois V. Collins; a sister, Lanna DeVites and husband John of Zuni, VA; 4 sons, Benjamin M. Collins and fiancée Samantha of Williamsburg, VA, Kenneth Collins and wife Kelly of Portsmouth, VA, Brian Seabold and wife Kelly of Chesapeake, VA, and George Seabold and wife Terri of Elizabeth City, North Carolina; a daughter, Lisa Berger and husband Keith Berger of VA Beach, VA; and 6 grandchildren, Marcus, Zachery, Grayson, Bryson, Jacob, and Trey.

## Service

I am not sure when my father's parents moved from West Virginia, but my Dad did grow up here locally in the Hodges Manor section of Portsmouth, Virginia - right next to Elizabeth Manor Golf & Country Club. Dad graduated from Portsmouth High School with the class of 1965. He was drafted into the US Army and trained at Fort Jackson, South Carolina.

Dad, served two years in Vietnam from 1966 to 1968. Like most veterans, he never talked about his service. After he passed, I decided to use DD 214 to order replacement decorations. Thankfully, the Medals Of America company put in a rush order for me so we could decorate his uniform for the memorial service. He also saved his short-timers stick and jacket with hand sew patches and lettering. The text on the back of the jacket says "I am certain to go to Heaven because I spent my time in Hell."

Below is a list of his decorations:

* National Defense Service Medal
* Vietnam Service Medal
* Republic of Vietnam Campaign Medal w/60 Device
* Good Conduct Medal
* Expert Badge (M-14 Rifle)

Shortly after serving in the Army, my Dad joined the Portsmouth Police Department where he served till mid 1974, a few years after I was born. During his time there he became a Detective, State Arson investigator, and served on the bomb squad. His detective work focused on the narcotics division and he served much of that time undercover. I have numerous family photos with my Dad sporting pot leafs on his shirt or a nice Budweiser cap. After he passed, I finally found a copy of his resignation letter with the force where he quoted salary and the need to be more of a "family man".

After resigning from the force, Dad started a private investigation company with a long time friend, Ken Riddleberger. It was aptly named Double K Incorporated and they primarily handled arson and insurance fraud cases. Dad did this till the late 80's. I really believe he thought of himself as Magnum PI. Often he would wake up in the morning and drive around calling out on the CB Radio till his partner Ken Riddleberger woke up and did the same. They would promptly head towards a local Texaco station where they would play Ms. PacMan while they discussed their case load.

Because investigation work often required a lot of travel, Dad eventually got a desk job as head of security at the Portsmouth Naval Base and eventually came back to law enforcement with the Chesapeake Sheriff's office. I am very proud of my father's service and work. Below are some shadow boxes I made to commemorate his service.

## Lifestyle

Dad was an avid golfer! I mean really, he played every spare moment he could and passed the love of the game to both my brother and myself. We owned our first set of clubs at the age of 9 after Dad won a tournament at Bide-A-Wee golf course. Dad loved the game so much, the family opened up a small golf shop in Chesapeake called Links Golf Shop. Ben and I even attended the GolfWorks school for club manufacture and repair in Newark, OH.

Golf was not our only sport. For some reason Dad made me and my brother try our luck with many others. We played basketball, football, and baseball. Most years we played baseball and even though we both sucked and never had more than a 0 batting average, Dad was there for us and helped coach all of our teams.

After getting divorced in 1991, my Dad eventually remarried in July 2006 to Lois V. Collins. Dad and Lois met at a Parents Without Partners (PWP) group and dated for some time.  I can not count the number of times she would drive them both to his favorite destinations or other out of state trips. Lois will always be a Collins and is family to me. I love her dearly.

## Stories

My Mom, Linda Campbell - now remarried, recently told this story to my Brother and myself and I hope she does not mind sharing it here.

> Your Dad and I must have been in junior high school, you know the age where you are scared and everything embarrasses you and you know if you do anything, it will be wrong? I remember feeling especially confident though because I had on an ironed white shirt and a brand new pair of Bermuda shorts that my mom had sewn for me. I was Sandra Dee and – well, we didn't really know each other or hang out at the time but we were with a bunch of neighborhood kids all hanging around on a hot summer day with nothing to do.
>
> As it was back then, kids didn't hang out inside so we were all standing and sitting on a friends chain link fence and being shy about the opposite sex. I was one of the kids on the fence, don't know why, because the wire went above the top pipe bar and was not very comfortable at all to sit on. The kids generally agree to go beg something cold to drink from one of the mothers – mothers were always home back then, just like June Cleaver. So, I jumped down from the fence.
>
> Uh-oh, my feet hit the ground, but most of my brand new Bermuda shorts were still attached to the wicked fence. Standing there in my white cotton undies and very little of my shorts, I wanted to crawl under the fence. Everyone was laughing and making fun – everyone but your Dad. He calmly went to the clothes line and pulled down an ironing board cover that had dried in the sunlight and approached me with his head turned sideways, and his arms spread wide, holding the ironing board cover for me like a mother holding a towel for a wet toddler emerging from the bathtub.
>
> We didn't cross paths again until after graduation, when he worked at James' Texaco. I had just gotten my new spiffy, metallic blue Corvair with 4 in the floor and was gassing up at his station, trying to look prim and proper. He never mentioned the shorts eating fence until later but when he asked me on a date, I remembered his gallantry from many years earlier.

## In Closing

The Collins family has always been close, despite long durations without seeing one another. Often times I went weeks without checking in on my immediate family. The great part about family is that you can always pick up right where you left off. Time has no meaning. But with my Dad's passing, I will really miss that next time when I want to call and talk to him.

## Other Links

* [Hollomon-Brown Obituary](http://www.hollomon-brown.com/obituary/Kenneth-Earle-Collins/Chesapeake-VA/1158699)
* [Medals Of America](http://www.medalsofamerica.com)


text:
# Graph Filtration Kernels

```
@inproceedings{gfk_aaai22,
title = {Graph Filtration Kernels},
author = {Till Hendrik Schulz and Pascal Welke and Stefan Wrobel},
booktitle = {Proceedings of the Thirty-Sixth Conference on Association for the Advancement of Artificial Intelligence (AAAI)},
year = {2022}
}
```

links
- [arXiv](https://arxiv.org/abs/2110.11862)


text:
# DynamicStorm
This python3 module is for the vector file which is output from DynamicStudio.

Functions:

- applying incorrect vector filter to instant data list
- turbulent statistics
- space averaging

## Getting Start
- [Setup](docs/setup.md)

## Manual
- [Manual](docs/manual.md)

## Sample
- [Single set data analysis](https://gist.github.com/fiftystorm36/71a2977ea9fa959e672eb95697778cce)
- [Several set data analysis (same range)](https://gist.github.com/fiftystorm36/45adbd91fd327ba65cc1b34e6dd76c1b)
- [Several set data analysis (different range)](https://gist.github.com/fiftystorm36/0c65fcbb8c6320552cccdde4caa59197)


text:
# scraping
a repository that contains sample cedes for scraping

--download_series_pdf_tutorials.py

This code enables us download a series of pdfs automatically!
For example,we want to download the pdfs like this:

https://www.ce.jhu.edu/dalrymple/classes/602/Class1.pdf
https://www.ce.jhu.edu/dalrymple/classes/602/Class2.pdf
.
.
.
https://www.ce.jhu.edu/dalrymple/classes/602/Class15.pdf

Just enjoy your reading!

repository: antenna-before/scraping

repo_name: antenna-before/scraping


text:
# Contributing

You are more than welcome to contribute by creating pull-requests.

See [Badge](https://github.com/wix/wix-style-react/blob/master/src/Badge/Badge.js) component for reference

### UX

For any questions regarding product design/UX please contact [Ben Benhorin](https://wix.slack.com/messages/@benb).

### Components design (in progress)

* This library is using es6 + jsx
* All assets are in `src/assets` folder
* Each component must have e2e & unit test as well as testkit provided. (It is recommened to make your testkits API the same across all testkit types)
* One React component per file
* Most of the components needs be a [controlled components](https://goshakkk.name/controlled-vs-uncontrolled-inputs-react/), if you still think that a component should be uncontrolled after you read the article you are welcome to push a pr for it.
* Components needs to support rtl and ltr props

### Adding new component

* Check [Adding new components](https://github.com/wix/wix-style-react/projects/1) project if someone already working on your component or there is an open issue for that component
* If no one is working on it and no issue exists:
    * create a new issue for your component;
    * add it to [Adding new components](https://github.com/wix/wix-style-react/projects/1) -> “In Progress”;
    * assign it to yourself.
* Add the component docs to [stories](https://github.com/wix/wix-style-react/tree/master/stories)

    > refer to [Badge docs](https://github.com/wix/wix-style-react/blob/master/stories/Badge/index.js) for example.

    * A story consists of properties, usage examples and code examples,
    * use [`AutoDocs`](https://wix.github.io/wix-style-react/?selectedKind=Introduction&selectedStory=AutoDocs&full=0&down=0&left=1&panelRight=0) to automatically generate table of props,
    * Make sure to add your component to [Storybook config](https://github.com/wix/wix-style-react/blob/master/.storybook/config.js)
* Add component test, e2e and drivers to the component's folder.
* Add index.js file to the component's folder and export your component.
* Export your testkitFactory from the following files:
    * `wix-style-react/testkit/index.js`
    * `wix-style-react/testkit/enzyme.js`
    * `wix-style-react/testkit/protractor.js`

### Enhancing an existing component:

* Check [Enhancing existing components](https://github.com/wix/wix-style-react/projects/2) project if someone already working on your request or there is an open issue for it
* If no one is working on it and no issue exists:
    * create a new issue;
    * add it to [Enhancing existing components](https://github.com/wix/wix-style-react/projects/2) -> “In Progress”;
    * assign to yourself.

repository: kupriyanenko/wix-style-react

repo_name: kupriyanenko/wix-style-react


text:
Array Buffers are the backend for Typed Arrays. Whereas `Buffer` in Node is both
the raw bytes as well as the encoding/view, Array Buffers are only raw bytes and you
have to create a Typed Array on top of an Array Buffer in order to access the data.

When you create a new Typed Array and don't give it an Array Buffer to be a view
on top of it will create its own new Array Buffer instead.

## Challenge

For this challenge, take the integer from `process.argv[2]` and write it as the first
element in a single-element `Uint32Array`. Then create a `Uint16Array` from the Array
Buffer of the `Uint32Array` and log out to the console the JSON stringified version
of the `Uint16Array`.

Bonus: try to explain the relevance of the integer from `process.argv[2]`, or explain
why the `Uint16Array` has the particular values that it does.

## Hints

Read more about Typed Arrays here:

  http://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays

also: JSON.stringify() FTW!

To get output for debugging when running `{appname} run program.js`
you should use `console.error` instead of `console.log`.

repository: MarcManiez/bytewiser

repo_name: MarcManiez/bytewiser


text:
# NodeEditor
The NodeEditor is a Swing UI component that immitates the NodeEditor from 3D graphics editor Blender. It allowes the user to drag, resize and connect graph elements.

license: Unlicense

repository: terifan/NodeEditor

gha_language: Java

gha_license_id: Unlicense

repo_name: terifan/NodeEditor


text:
# F2J in Sublime Text

[![License BSD 3][badge-license]](LICENSE)

F2J plugin for Sublime Text

## Features

* Syntax highlighting

* Commenting

* Some code snippets

## Installation

Search `F2J - FCore to Java` on [Package Control](https://packagecontrol.io).

## License

BSD 3

[badge-license]: https://img.shields.io/badge/license-BSD_3-green.svg


text:
![clubCamp](https://socialify.git.ci/kavania2002/clubCamp/image?description=1&font=Bitter&language=1&owner=1&theme=Light)
<br>

# clubCamp
- clubCamp is a **CAMPSITE**(website) for universities where clubs work collaboratively. It provide a platform where studetns can register for open for all events ofthe clubs. As the name suggests clubCamp is all about fun-learning and gaining experience. All the recent events and workshops conducted by the clubs are displayed so it becomes easy for students to see. Club gets the oppurtunity to register themselves and display their events and workshops. It displays upcoming and ongoing events as well as thier registration link and organizer's inforamtion.

## Tech Stack
- **Frontend:** HTML/CSS/Bootstrap/JavaScript
- **Backend:** Django

repository: AkshilVT/clubCalendar

branch_name: refs/heads/main

repo_name: AkshilVT/clubCalendar


text:
---
uid: seveneng
date: 2017-01-09
enddate: 2017-01-15
week: 3
generator: furore
---

- Read literatures about model-based data compression. Found two algorights that might be apt to integrate into pih-store, Adaptive Piecewise Constant Approximation and Slider Filter. They are both online processing algorights. The idea is to cut the stream of data into appropriate segments, and fit the data in each segment to a specific linear function. Next week, may try to implement the first version of this.

- Continued learning about the design and structure of `packetdrill`. Still not clear about what shoud the statck test framwork should look like.

- Browsed some repos that use `topkg` from [doc page](http://erratique.ch/software/topkg/doc/Topkg.html#menagerie), finished learning how to use it.

repository: ocamllabs/ocamllabs-www

gha_language: CSS

repo_name: ocamllabs/ocamllabs-www


text:
---
title: Art for Milwaukee
date: 2018-01-28T14:00:00-06:00
---
Logos and art I create for things in the city of Milwaukee. I've long loved the city
even before I got to call it home, and now that it is, I take any chance I get to
contribute to its existing richness in art.
<!--more-->

## Milwaukee public market logo remake
I imagined what a different logo on https://milwaukeepublicmarket.org/ will look like. I really don't know how long the existing logo
have lived but I was shooting for something a little more modern and landed at this.

![Milwaukee public market new logo](https://cdn.dribbble.com/users/469450/screenshots/3715209/media/0c311ccebaa35ecbbee0a9939dabf202.jpg)

## Channel shifting + Smoke animation of MKE

{% image '49933920_391818328060375_5642777912430134632_n_hd8r5t', {alt: 'channel shifted photo of downtown milwaukee', width: 720, height: 720} %}

{% youtube 'FgXPP7codCQ', 'Channel shifting + smoke animation of MKE at Milwaukee downtown area' %}

## Logo for MKE JAVA meetup

{% image '51042736_1889154564540694_2044730601706469746_n_qaldxz', { width: 800, height: 800, alt: 'MKE Java logo design' } %}

gha_language: HTML


text:
System.Runtime.CompilerServices.Unsafe [4.5.3](https://www.nuget.org/packages/System.Runtime.CompilerServices.Unsafe/4.5.3)
--------------------

Used by: SqlDatabase internal

Target frameworks: net472, net5.0, net6.0, net7.0, netcoreapp3.1

License: [MIT](../../../../licenses/mit)

- package license: [MIT](https://github.com/dotnet/corefx/blob/master/LICENSE.TXT)
- project license: [Unknown](https://dot.net/) , License should be verified on https://dot.net/

Description
-----------
Provides the System.Runtime.CompilerServices.Unsafe class, which provides generic, low-level functionality for manipulating pointers.

Commonly Used Types:
System.Runtime.CompilerServices.Unsafe

7601f4f6225089ffb291dc7d58293c7bbf5c5d4f
When using NuGet 3.x this package requires at least version 3.4.

Remarks
-----------
no remarks

Dependencies 0
-----------

*This page was generated by a tool.*

repository: max-ieremenko/SqlDatabase

gha_language: C#

repo_name: max-ieremenko/SqlDatabase


text:
# n-pointed-stars

This is JavaScript program that draws pentagram-like stars, but with
_n_ points instead of 5, and with various step sizes as you walk around
the perimeter of a regular polygon with _n_ sides.

This same code is also available as an [Observable](
https://observablehq.com/@perlmonger42/drawing-n-pointed-stars)
and as a [JSFiddle](https://jsfiddle.net/perlmonger42/e84bqkhx/106/).

## Notation
`STAR[n,s]` names a pentagram-like star with _n_ points with line segments
joining corners that are _s_ steps apart.

Each line segment of the star connects a corner of the _n_-gon to the _s_-th
successive corner (the point that is _s_ steps clockwise around the corners
of the _n_-gon).

As an example, `STAR[5,2]` is a pentagram, which is constructed on the corners
of a pentagon.

When _n_ and _s_ are relatively prime, the line segments form a single polygon
that visits all the corners of the star. The polygon may be
self-intersecting, as in the case of a pentagram, and might also be a
polyline (that is, it might not be a closed loop).

But sometimes it takes more than one polygon to cover all the corners. For
example, `STAR[6,2]` is the Star of David, which is made up of two separate but
overlapping equilateral triangles. Similarly, `STAR[9,3]` is a 9-pointed star
made of 3 overlapping equilateral triangles.

`STAR[n,[s0,s1,...]]` is a generalization, where the step size between corners
is not the same every time. Instead, the first step is s0, then s1, etc.
When the step sizes are exhausted, they are reused as many times as needed.
STAR[n,[s]] is equivalent to STAR[n,s].

![Stars with 2 points, 3 points, ..., and 13 points](stars.svg)

## Code Overview

This is a small project. It defines just seven JavaScript functions:

### `function regularPolygonCorners(sides, centerX = 0, centerY = 0, radius = 100)`

Return the list of points for the regular polygon with the given radius and
number of sides, whose center is at (centerX, centerY). The polygon is
oriented with first vertex on the positive Y axis, and subsequent vertices
are in clockwise order.

The returned value has structure like [[-1,0], [0,1], [1,0], [0,-1]].

### `function cycle(start, size, steps)`

Returns

    [start,
         (start + step0) % size,
         (start + step0 + step1) % size,
         (start + step0 + step1 + step2) % size,
         ...
         (start + step0 + step1 + step2 + ... + step0) % size,
         (start + step0 + step1 + step2 + ... + step0 + step1) % size,
         ...
    ]

In other words, beginning at `start`, it takes consecutive steps around the
polygon of different sizes, as indicated by the `steps` array. When the array
has been exhausted, it goes back through the array again as many times as
necessary.

Returns a list up to but not including a duplicate line segment.

Used by `starIndices()`.

### `function starIndices(size, stepSizes)`
Return `STAR[size,steps]`, as a list of lists of corner numbers.

Produces the index lists that abstractly describe `STAR[size,steps]`.
Each list of indices represents an abstract polygon -- abstract in the
sense that, rather than being a list of points, it's a list of corner
numbers.

Used by `star()`.

#### Example 1
The star indices for the pentagram (a.k.a. `STAR[5,2]`) are [[0, 2, 4, 1, 3]].
The top-level list contains only a single list, because the pentagram is a
single polyline. The content of that list indicates that the polyline starts
at corner #0, then visits corners #2, #4, #1 and #3 in order. The return to
corner #0 is implicit.

#### Example 2
STAR[6,2], the Star of David, has indices [[0, 2, 4], [1, 3, 5]].
There are two lists, each containing the vertex numbers of a triangle.

Used by the main block of code that draws STARS[n, ...] for _n_=3 to 13.

### `function uniqueKeyForIndexList(indexLists)`
Return a canonical string describing the given indexLists.

Any two indexLists that would result in the same line segments being drawn
should return the same canonical string.

### `function rotateIndexLists(sides, indexLists)`
Rotate the given star one step clockwise.

Used by `uniqueKeyForShape`.

### `function uniqueKeyForShape(sides, indexLists)`
Return a canonical string describing the given shape.

Any two stars that are rotations of each other should return the same
canonical string.

This implementation just finds the minimum uniqueKeyForIndexList over all
possible rotations.  Reflections of the same shape are not being detected,
but I haven't spotted any reflection-duplicates in the output.

Used by the main block of code that draws STARS[n, ...] for _n_=3 to 13.

### `function star(sides, starAsIndices, centerX, centerY, radius)`
Return an SVG representation of a star,
drawn with the given radius and center location.
The input star is in starIndices format (a list of lists of corner numbers).


text:
# Machine Learning Based Trading Strategies for Emerging Markets

This Jupyter notebook creates, trains, and evaluates machine learning models to automate trading decisions for emerging markets investing.

Specifically, it carries out the following steps:
1. Implements a baseline trading strategy based on dual Simple Moving Averages (SMAs) using the Support Vector Machine (SVM) C-Support Vector Classification (SVC) model.
2. Adjusts the training data size and the moving average windows to optimize the algorithm.
3. Trains a model using a different machine learning model and compares its performance to the baseline model.

---

## Technologies

This Jupyter notebook makes use of the following Python libraries:
* Pandas
* PyViz - Holoviews and hvPlot library
* Datetime
* Numpy
* Matplotlib
* scikit-learn

---

## Installation Guide

To use this notebook:
* Install Jupyter lab Version 2.3.1 and Python 3.7.
* Pandas should already be included in the dev environment distribution.  If not, install it.
* Install scikit-learn.
* Install PyViz visualization package.
* Install hvPlot version 0.7.0 or later.
* Install NodeJS version 12 or later.

Open the notebook in Jupyter lab and you can rerun the analysis.

---

## Machine Learning Models
### Baseline SVC Model

#### Classification Report
```
              precision    recall  f1-score   support

        -1.0       0.43      0.04      0.07      1804
         1.0       0.56      0.96      0.71      2288

    accuracy                           0.55      4092
   macro avg       0.49      0.50      0.39      4092
weighted avg       0.50      0.55      0.43      4092
```

![Emerging Markets - Dual SMA Machine Learning Strategy - Baseline](Images/dual_sma_strategy_baseline.png)

The baseline model had an accuracy of 55%.  The Strategy Cumulative Returns were 151.8%, and the Actual Cumulative Returns of the emerging markets data were 138.7%.  So for the baseline case, the model performed 13.1% better than the underlying assets.

### 6-month Trained SVC model

#### Classification Report
```
              precision    recall  f1-score   support

        -1.0       0.44      0.02      0.04      1732
         1.0       0.56      0.98      0.71      2211

    accuracy                           0.56      3943
   macro avg       0.50      0.50      0.38      3943
weighted avg       0.51      0.56      0.42      3943
```
![Emerging Markets - Dual SMA Machine Learning Strategy - 6 Month Train](Images/dual_sma_strategy_6mo_train.png)

When the model was trained with 6 months of data instead of 3, overall the model performed better than the baseline.  The accuracy went up to 56%, the Strategy Cumulative Returns went up to 184.2%, and the Actual Cumulative Returns of the emerging markets data went up to 156.0%.  Note there was a period about 1 year where the model performed worse than the underlying assets, but in the end the model performed 28.2% better than the underlying assets.

Also note the reason the Actual Cumulative Returns went up compared to the baseline was because the 6 months of training data changed the amount of data available used by the cumulative product comparison.

### SMA Window Tuned SVC Model

#### Classification Report
```

              precision    recall  f1-score   support

        -1.0       0.44      0.85      0.58      1740
         1.0       0.58      0.16      0.25      2227

    accuracy                           0.47      3967
   macro avg       0.51      0.51      0.42      3967
weighted avg       0.52      0.47      0.40      3967
```

![Emerging Markets - Dual SMA Machine Learning Strategy - 4/200 Window](Images/dual_sma_strategy_4_200.png)

When the SMA fast/slow windows were changed from 4/100 days to 4/200 days, it had a negative impact on the model.  Compared to the baseline, the accuracy went down to 47%, the Strategy Cumulative Returns went down to 96.6%, and the Actual Cumulative Returns of the emerging markets data went up to 156.6%.

Note the reason the Actual Cumulative Returns went up compared to the baseline was because the 200-day window changed the amount of data available used by the cumulative product comparison.

### DecisionTreeClassifier Model

#### Classification Report
```
              precision    recall  f1-score   support

        -1.0       0.44      0.57      0.50      1732
         1.0       0.56      0.44      0.49      2211

    accuracy                           0.49      3943
   macro avg       0.50      0.50      0.49      3943
weighted avg       0.51      0.49      0.49      3943
```

![Emerging Markets - Dual SMA Machine Learning Strategy - DecisionTreeClassifier](Images/dual_sma_strategy_dtc.png)

The new model built using a DecisionTreeClassifer performed worse than the baseline model and the 6-month Trained SVC model.  It performed slightly better than the SMA Window Tuned SVC model, although that is not a fair comparison because the new model was also built using 6 months of training data.

Compared to the baseline, the accuracy went down to 49%, the Strategy Cumulative Returns went down to 121.8%, and the Actual Cumulative Returns of the emerging markets data went up to 156.6%.

Note the reason the Actual Cumulative Returns went up compared to the baseline was because the 6 months of training data changed the amount of data available used by the cumulative product comparison.

## Conclusion

Based on the overall model accuracy and the comparison of Strategy Cumulative Returns with Actual Cumulative Returns of the emerging markets data, the recommended machine learning model is the 6-month Trained SVC model.

When backtested, this model produced cumulative returns of 184.2%, compared to cumulative returns of 156.0% of the underlying emerging markets assets.

---

## Contributors

Michael Danenberg

---

## License

MIT


text:
## Saturday Events
Dev Day
These events will be focused on developer stuff and will be more intimate.

game dev industry focus, with workshops, talks, etc, panel of people in the industry

## Sunday Events
Open house
This day is for mainstream audience to experience the event.

panels etc but with more laymen’s

#### Activities
- An open time for attendees to play developer games.
- Dev Panel Talk: A developer panel with speakers from the indie game convention.
- - Sponsers first, then see budget for keynote
- Developer Dinner: We host a dinner on Saturday with all the developers.
- - Who is catering, and ask mark david on costs for catering
- Programming Demo: A demo showcasing programming on how we make games.
- - Panel style, saturday advanced tech specific and/or sunday, laymans
- Art Demo: A demo showcasing art techniques.
- - Panel style, saturday advanced tech specific and/or sunday, laymans
- Scavenger Hunt: An AR scavenger hunt. Powered by Glimmer
- - Talk to vance, if we get sponsorship level we want to give you money, want to know terms, what do they expect from us.
- Collect Badges: For playing developer games. Badges provided by Badgr.
- - Talk to Nikole
- Prizes! For collecting Badges.
- - Don't know if we're gonna keep this stuff
- Physical chess game design jam
- - 30 min, workshop. saturday in depth for devs, sunday public works with developer 2-4 person team.

#### Misc
- Mobile beer carts
- - Sponsors, find sponsors, starlight, drink catering people
- Food catering
- - Sponsors, find sponsors, catering people.
- Nintendo truck
- - Contact eucon truck people, game trucks
- Programmer, designer, and artist and actually ask hard questions about what they want people to know, how to make game community and workforce better, what’s the industry like
- - Panel things, panel ideas, think of who we can invite
- Between presentations, have the sponsors talk for 2-5 minutes
- - depends on sponsors, food vendors, scheduling, remind sponsors day of
- Panel of mobile, 2D, 3D, AR, and VR game devs and talk about where those directions are headed, how best to market and sell each type of game
- - panel stuff for saturday, marketing
- Workshop for VR Mozilla web browser
- - panel stuff for saturday, marketing, contact josh m
- Demonstrations: mocap suit live demo
- - ask lcc and andy
- Collaborative sculpture where everyone puts a piece of clay on it on the first day and then the second day scan it and have mocap animation of it the next day
- - ask lcc and andy, due date, january/feb/march
- Every person who plays every game (and records it with the passport), they get their name in a hat or something and every couple hours a name is drawn and they could be one of the people to record their dance in the motion capture suit
- - ask lcc and andy, due date, january/feb/march, glimmertech need involvement

## Incentives and Prizes
Developers will be able to show off games that they have been working on and receive face to face feedback with developers.
Attendees will be able to play games that indie devs show off and provide face to face feedback with developers.

Developer Incentives and Prizes:
- Developers will get featured on the IndieGameCon website.
- Developer who gets the most played gets a prize.
- Developer who gets highest rating gets a prize.
- Possible publisher connections for highest rated?
- Gift card? Coffee prize? Cash prize?

Attendee Prizes:
- Play three games at the convention: receive a sticker
- Play every game at the convention: receive button
- Get highest total score at convention: recieve t-shirt

repository: andy-dandy/IndieGameCon

repo_name: andy-dandy/IndieGameCon


text:
# Auditing/Assessment 3: The False Promise of Risk Assessments: Epistemic Reform and the Limits of Fairness

| Item | Description |
| --- | --- |
| Presented By | Ben Green |
| Paper | [The False Promise of Risk Assessments: Epistemic Reform and the Limits of Fairness](https://dl.acm.org/doi/pdf/10.1145/3351095.3372869?download=true) |

## Notes

- Risk assessments are growing in use across the US criminal justice system, with the theory being:
    - They're objective
    - They replace discriminatory behaviours & lead to reform
- *The impossibility of fairness*:
    - If two groups have different rates of an outcome, then it is impossible for predictions about hose groups to both be calibrated and have balanced errors
![The impossibility of fairness](./impossibility_of_fairness.png)

- Formal & Substantive Equality
    - **Calibration**: formal equality
        - similar people should be treated similarly
    - **Error Rate Balance**: substantive equality
        - groups obtain similar outcomes, even if that requires accounting for different social conditions across groups
- Issues with algorithmic fairness:
    - Tend to sideline social context, justice etc
    - Can overlook social change & thus can reinforce discrimination


text:
# Go Challenge - 8

http://golang-challenge.com/go-challenge8/

## The Goal of the challenge

The goal of this challenge is to implement a Sudoku solver.

(Incidentally, the puzzle above makes a nice test case, because the solution is
easy to validate by sight.)

## Bonus features

* Print a rating of the puzzle's difficulty (easy, medium, hard). This rating
  should roughly coincide with the ratings of shown by sites like Web Sudoku.
* Implement a puzzle generator that produces a puzzle of the given difficulty
  rating.
* Maximize the efficiency of your program. (Write a benchmark.)
* Write test cases, and use the cover tool to make sure your tests are
  thorough. (I found a bug in both my implementation and a test case when I
  checked the coverage.)
* Use a non-obvious technique, like Knuth's "Dancing Links" or something of your
  own invention.

## Hints

* For an elegant and efficient representation of the puzzle, try using an array
  (not a slice).
* Recursion can dramatically simplify your implementation.


text:
# About
[![CodeQL](https://github.com/vic7z/CovidVaccineNotifier/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/vic7z/CovidVaccineNotifier/actions/workflows/codeql-analysis.yml)

A simple spring boot application that can track vaccine availability and automatically sends a SMS alert with the avilable centers

Features
  * Dose type selection
  * age group selection
  * Vaccine type selection
  * Paid/Free selection

You can register [here](https://notifier1.azurewebsites.net/)

repository: SaksheePhade/CovidVaccineNotifier

repo_name: SaksheePhade/CovidVaccineNotifier


text:
/*
Title: Installation Instructions
Description: How to install PHP Tools for Visual Studio
*/

## Basic Installation

You will need to have *Microsoft Visual Studio* installed before installing PHP Tools. You can download the free Community version [here](https://visualstudio.microsoft.com/vs/community/) or use any other Visual Studio version, except for Express versions, which are not supported.

If you already have Microsoft Visual Studio installed, you can jump directly to the **Manage Extensions** dialog and search for **PHP Tools for Visual Studio**.

![Visual Studio Extensions](imgs/install-from-vs.png)

Once downloaded, you'll be prompted to close Visual Studio. The package will be installed and Visual Studio configured for the PHP development. After starting Visual Studio next time, you can proceed to the [product activation](/vs/installation/activation) and [get started](/vs/).

If you woud like more detailed steps, please, continue reading.

## Prerequisites

In order to install PHP Tools for Visual Studio, you'll need:

- **Administrator access**. Please ensure you can provide administrator access to your hard drive, because the installation package copies files to system's *AppData*. For Visual Studio 2010 up to 2015, you'll be queried to allow access to system's *Program Files*.

- **Microsoft Visual Studio**. Install [Microsoft Visual Studio](https://visualstudio.microsoft.com/vs/). You can choose the **Community** edition, that is the **free** option, or any other Visual Studio´s supported editions, such as *Professional*, *Enterprise* or higher. Express editions are not supported.

<center markdown="1">

![Visual Studio Extensions](imgs/visualstudio-small.png)

</center>

## Download and installation

 PHP Tools' installation package can be downloaded from:

- [Visual Studio Marketplace](https://marketplace.visualstudio.com/search?term="php%20tools"&target=VS&vsVersion=)- choose PHP Tools edition according to the version of your Visual Studio.

- [DEVSENSE.com](https://www.devsense.com/en/download#vs)- you can download any version or any update of PHP Tools for Visual Studio directly from our website.

#### Instructions for installation:

Once you have downloaded PHP Tools:

1. Close *Visual Studio*
2. Run the installation package downloaded from any of the locations above
3. Follow the instructions on the screen.
4. Restart *Visual Studio*.

The software's installation package can also be used for an [offline installation](https://docs.devsense.com/en/vs/installation/offline-activation).

## Activation

The product contains both 30-day trial and the full product. When the trial is over, you can activate the software using a purchased license key. Please see [Product Activation](/vs/installation/activation) for more details.

## Updates

PHP Tools updates are checked automatically. Visual Studio will notify you about updates available. Please see [Update instructions](https://docs.devsense.com/en/vs/installation/updatet) for more information.

repository: meonBot/phptools-docs

repo_name: meonBot/phptools-docs


text:
---
title: The ICO Cookbook
subTitle: Everything that goes into a delicious ICO, more or less
category: "Blockchain"
cover: cook1.png
---

# The ICO Cookbook

Everything that goes into a delicious ICO, more or less

### Dish trivia

When an organization issues and publicly sells a token or cryptocurrency, it is called an initial coin offering or an ICO. The name is a reference to the traditional way of raising money through issuing shares (an IPO, or initial public offering).

![cook1](./cook1.png)

This new way of fundraising has several advantages compared to traditional means (VCs and IPO), namely a shorter time-span, lower barriers of entry, less bureaucracy, and the ability to build a user base at the same time of fundraising.

Preparation is required for an ICO. The level of convenience in fundraising has never been reached before, which is perhaps why the ICO or blockchain market boomed as it did.

This gives innovators a way to add value to their business or a market by leveraging the possibilities enabled by the blockchain technology. On the flip side, this also enables ill-intended fundraisers to quickly drain value out of the market to line up their own pockets.

At the time of writing (late 2018), investors are much less inclined to blindly invest much like the ICO craze around this time last year. Plus the maturing regulations, more blockchain projects are relying more on private sale and reaching out to known investor pools/VCs.

### Ingredients

* Proof of concept —— 2 cups, washed

* Technical —— 1 bowl, chopped

* Legal —— 3 pcs

* Presence —— to-taste

## Preparation

## Proof of concept

An ICO is not venture capital nor an IPO. Some companies reach a point where they need capital for further operation or expansion, and they see ICO as a mean to reach the most investors and generate the most funds. When there’s no innovation or purpose to a token, the token is destined to fall short of its hype. It’s just wanton without filling.

![cook2](./cook2.png)

ICO is a tool for creative blockchain projects or use-cases to reach a funding so they get built. The key word here is **blockchain project**.

### Token Utility Value

What makes a token different from a share or a loan agreement is its utility. If the product or platform could function just as well without the tokens, a blockchain and an ICO on top, there is no reason to ICO with few exceptions.

Find the token utility value or an exceptionally good reason to not have one.

Consider the full project’s scope such as its vision, addressed problems, timeline, market fit, competition, unique value proposition, revenue model etc.

### Token Economics

For each use case, there’s a different price to ask for over a different time frame. Address these basic token design questions:

* What is the price of the token?

* What bonuses are offered over which period of time?

* How will new currency be introduced, or is the supply fixed?

* What is the token allocation?

### Organization

The organization and its partners’ main goal is to deliver promises of the ICO.

The founder and team are experts in their related fields. When there are areas to be complimented, look for advisors. For example, when expecting legal challenges during proposal of their business model, a local legal advisor provides use by making sure each action the business takes is in compliance with local regulations. Each name on the roster list has a clear purpose in the big picture.

Early contributor and team tokens may have a mechanism in place to prevent dumping immediately post ICO.

## Technology

The technology involved in an ICO could be simple and straightforward, or technologically innovative and complex, depending on the end goal.

If the product use case is simple, a token platform like Ethereum, Steller, and NEM suffices; if the company seeks to improve an existing blockchain protocol or introduce a new consensus model, a token platform can act as an intermediary mechanism to fund development.

Choosing a platform has implications, namely the accepted currency, existing community, and platform support.

![cook3](./cook3.png)

The smart contract or mainnet in development reflects the token design/economics, so its source code is usually open source for community trust.

Preparing this part can be quick and easy, but don’t cheap out on extensive testing and auditing. They maximize security, which limits the unseen inconveniences or disasters that may come through the cracks.

## Legal

Aside from drafting standard legal documents such as a Terms of Service, Token Purchase Agreement, Disclaimer, Privacy Policy… there are a few more steps.

![cook4](./cook4.png)

### Location location location

Decide the location twice: the location of the token-issuing entity, and the location of investors.

Most ICOs issue their tokens in Singapore or Switzerland. There are local securities laws, KYC/AML laws, and regulations to follow.

Although ICOs target globally, ICO investors from a few regions are problematic to deal with, such as China and the United States of America. Choose the locations of your investors.

Digital token bookkeeping, accounting, and auditing are necessary considerations in the context of local jurisdiction and taxation.

### Whitepaper

Perhaps the most important document of an ICO, a whitepaper is a mix of a company constitution, business plan, technical spec sheet, and pitch deck. A specification does not yet exist. Investors review it to ensure the legitimacy, feasibility, and prospect of a project; regulators review it to ensure the project is in compliance of financial and security regulations; press base their judgment and releases on it.

Put all previously prepared items in an accessible and well-documented manner in the whitepaper.

Liberally use designers, legal experts, and blockchain experts for formatting, auditing, and proofreading.

Optionally localize resources, including the whitepaper, to a different language, to increase outreach and trust from more communities.

## Presence

Publish the whitepaper. It is the usual first step to establish a presence for an ICO. Ideally, the ICO branding and a well laid-out website are already in place. ICO branding goes a long way in establishing credibility since a book is usually judged by its cover.

Set up a one-way communication channel such as a newsletter. It may prove more useful than one might assume. Many investors are interested in keeping up to date of a project in this simple yet direct way.

### Marketing

Some projects never reached their goals due to a simple lack of coverage; then some projects receive too much attention and got shut down by authorities. Like most things, marketing works best in moderation.

![cook5](./cook5.png)

Make physical presences in road shows and conferences to engage audiences. Some companies make a point to show up at every major crypto event during the sale period.

### Social media

Tools such as Facebook, Twitter, and Reddit allows a company to reach a significant share of cryptocurrency investors. Slack and Telegram serve a different purpose than outreach, which is community management. The latter tools encourage discussion within the community.

Once a sizable user base is reached, hire dedicated social media managers and content creators to keep the community in control.

Prepare an FAQ to ease the load of community engagement. Pointing confused investors to an FAQ saves major resources.

Keep in mind, though, social media channels are the most common entry points for scammers to exploit.

Use incentive programs such as airdrops, referral bonuses, and bounty programs to promote organic growth.

Invest in SEO and listing services for visibility in lieu of advertising, since the most popular advertising platforms simply disallow ICOs.

Use public relations to create an advantage, since cryptocurrency prices are heavily dictated by the flow of information.

## Cooking directions

Decide how to accept funds. Try integrating a payment page on the official site, or try providing addresses to send contributions to.

There are ICO platforms that collect on behalf of listed projects and take a cut, similar to Kickstarter’s model. These platforms are seen as escrow services by the public, thus giving some assurance on their investment.

![cook6](./cook6.png)

### Presale

Before the main token sales event, a presale, lasting a few days, offering not more than a few percents of the total supply may take place. This is for investors who see substantial potential in the project, or an existing customer base a company wants to give preference to. In usual cases, the bonus during this period is the greatest.

### Main sales event

Ideally, market outreach is phenomenal and receptions are acclaimed, the actual sale period is over in an hour, and there are no leftover tokens to worry about.

In the more usual case, the sale will span over a predetermined sales period lasting a month on average. The token sale can be spread over multiple rounds but usually, there is only one. The token price can be fixed but it usually increases over the ICO period.

If there are leftover tokens, either burn, freeze, seize, or distribute them. There are merits to each approach.

### Post ICO

Investors will look for ways to liquidate, and disaster is sure to follow if a company fails to provide one in a timely manner. Getting listed on exchanges is the reasonable next move post-ICO. Most smaller exchanges accept listing at a fee, while the larger ones require the ICO to maintain their spotlight on top of the fee. Some opt to create their own exchanges and wallets to get around the fact.

![cook7](./cook7.png)

Finally, let the free market determine the value of the coin. If the project grew substantially during the ICO, the value of the token will reflect that.

![cook8](./cook8.png)


text:
---
layout: article
title: "Weekly Word: Contiguous"
date: 2009-07-20 22:32
cats: [english]
---
Contiguous is an adjective that means "touching", "adjacent", or "near" -- either physically or with respect to time.

It comes straight from the Latin word contiguus, a combination of com-, "together", and tangere, "to touch".

I like this word because of the overarching, fundamental concept it represents. Just take a look at Wikipedia's page on Contiguity to see its specific meanings in different areas of study. It shows up in everything from physics to psychology!

But contiguous shows up most often in the phrase "the contiguous United States", which refers to the 48 states "on the North American continent south of the border with Canada, plus the District of Columbia" (Wikipedia).


text:
Engine Extensions

The Basics

iOS / Android

Flash

Advanced Topics

Native Events

Custom Blocks

API

Toolset Extensions

Main Guide

API

## Contents

* Introduction
* Setup
* Walkthrough
  * How to Create an Extension (iOS)
  * How to Create an Extension (Android)
  * External Libraries
  * Building from Command Line
  * Editing Build.xml
  * Sending Data back from Native to Haxe
* Tips

## Introduction

Native Extensions allow Haxe code to call Objective-C, C++ or Java code, thereby allowing your games to take advantage of native functionality and APIs.

These extensions accomplish this by getting **pointers** to those native functions and then calling them. Although the exact details differ slightly between iOS and Android, the underlying concepts are the same.

## Setup

#### Before You Begin

* Read our [article](https://www.stencyl.com/help/view/how-to-create-engine-extension/) on Engine Extensions.

* Check out the **test-native** extension (under [WORKSPACE]/engine-extensions) to familiarize yourself with the parts. **test-native** shows how to create an Alerts extension that works both on iOS and Android. We reference this example throughought this article.

> **[WORKSPACE]** refers to the path to your Stencyl workspace (find it using Debug > View > View Workspace Folder).

#### Add Haxe to your Path

If you're writing an iOS or Android extension, you must add a couple items to your computer's "path" before proceeding, so that our bundled install of Haxe is recognized by the system.

> **Note:** If you prefer to use your own install of Haxe, you must use Haxe 3.1. Don't forget to install Neko too.

**Mac**

Run the following in Terminal.

```
export DYLD_LIBRARY_PATH=/path-to-stencyl/plaf/neko-mac
export PATH=$PATH:/path-to-stencyl/plaf/neko-mac
```

**Windows**

Add the following path to your system path.

```
/path-to-stencyl/plaf/neko-win
```

**Linux**

Run the following in the command line.

```
export LD_LIBRARY_PATH=/path-to-stencyl/plaf/neko-linux
export PATH=$PATH:/path-to-stencyl/plaf/neko-linux
```

## How to Create an Extension (iOS)

> **Note:** This section walks through the test-native extension and explains how the system works. The test-native extension adds Alerts to iOS and Android games.

#### The 3 Parts
Every iOS extension consists of 3 parts.

1. **Haxe code** that your game calls. This Haxe code fetches function pointers to native code and calls them
2. **C++ code** that sets up a mapping between those function pointers and Objective-C code.
3. **Objective-C code** that does stuff in iOS.

#### Part 1 - The Haxe code

The purpose of the Haxe portion of the extension is twofold.

* It exposes an API for your game (and blocks) to use.
* It fetches function pointers to native code and calls them.

Open up **NativeTest.hx**. Find the following code near the bottom (~line 42).

```
static var iosAlert = nme.Loader.load("ios_alert", 2);
```

In this snippet, we're getting a "function pointer" to `ios_alert`, a C++ function. The first parameter is the name of the function. The second parameter is the number of parameters that function takes.

Now look for this (~line 24).

```
#if(cpp && mobile && !android)
iosAlert(title, message);
#end
```

Here, we're calling the function whose pointer we fetched as described above. The `#if(cpp && mobile && !android)` are pre-processor flags that only let this code execute on certain targets. In this case, this is a roundabout way of saying "only do this on ios".

#### Part 2 - The C++ "Mapping"

The purpose of the C++ code is to establish a mapping beween Haxe and Objective-C.

Open up **project/common/ExternalInterface.cpp**. This file is the "glue" that connects Haxe to the underlying Objective-C code. (We've shortened the code to the essential bits for brevity.)

```
using namespace nativetest;

#ifdef IPHONE
void ios_alert(value title, value message)
{
    showSystemAlert(val_string(title), val_string(message));
}
DEFINE_PRIM(ios_alert, 2);
#endif
```

As you can see, `ios_alert` shows up again. This time, it's a function. That's where that function "pointer" is coming from in the Haxe file!

The `DEFINE_PRIM` part specifies how many parameters the function has.

`showSystemAlert()` is a direct call to a function in Objective-C. `val_string()` casts an arbitrary value to a String.

Now, let's look at the Objective-C part of the extension.

#### Part 3 - Objective-C

Objective-C is typically where the "meat" of an iOS extension is implemented.

You may have noticed that `ExternalInterface.cpp` imports NativeTest.h (peek at the top). If you open **project/include/NativeTest.h** and **project/iphone/NativeTest.mm**, you can see that this is plain old Objective-C.

```
namespace nativetest
{
    void showSystemAlert(const char *title, const char *message)
    {
        UIAlertView* alert= [[UIAlertView alloc] initWithTitle: [[NSString alloc]
                   initWithUTF8String:title]
                   message: [[NSString alloc] initWithUTF8String:message]
                                              delegate: NULL
                                              cancelButtonTitle: @"OK"
                                              otherButtonTitles: NULL];
        [alert show];
    }
}
```

#### Recap

To recap, an iOS extension effectively consists of 3 parts.

* Haxe source that fetches **function pointers** to native code and calls them.
* **ExternalInterface.cpp** provides those native calls and acts as the "glue" between Haxe and Objective-C.
* Objective-C (headers and .mm implementations) act as the implementation.

This is summarized in the following diagram.

![stencyl-levels-of-abstraction](https://static.stencyl.com/pedia2/chapter-d/LevelsOfAbstraction.png)

Now, we'll look at Android. Thankfully, the story is quite similar.

## How to Create an Extension (Android)

> **Note:** This section walks through the test-native extension and explains how the system works. The test-native extension adds Alerts to iOS and Android games.

#### The 2 Parts
Every Android extension consists of 2 parts.

* Haxe code that your game calls. This Haxe code fetches function pointers via JNI in order to let your Haxe code call Java code.
* The Java code that does stuff in Android.

> In contrast to iOS, Android doesn't have that intermediate layer of C++ to worry about, but the Haxe part is a little bit more complex to compensate.

#### Part 1 - The Haxe Code

Just like, in the iOS case, the purpose of the Haxe portion of the extension is twofold.

* It exposes an API for your game (and blocks) to use.
* It fetches function pointers to native code and calls them.

Open up **NativeTest.hx** and find this line (~line 30).

```
androidAlert = nme.JNI.createStaticMethod("NativeTest", "showAlert", "(Ljava/lang/String;Ljava/lang/String;)V", true);
```

Here, we're getting a "function pointer" to **showAlert()**, a Java function on the native side of things. The syntax is more complicated due to the use of [JNI](https://www.stencyl.com/help/view/jni-guide), the standard way of exposing native code to Java. Think of JNI as the rough equivalent to what ExternalInterface.cpp was doing for iOS, just in a more compact form.

Now, let's look right below (~line 33)

```
androidAlert([title, message]);
```

Here, we're calling the function, but the syntax is a little different. Instead of padding in the parameters directly, we're wrapping them inside an array.

> **Aside:** In some extensions, you may encounter an alternate approach where the array is pre-defined and passed in. For example, our Ads extension does this.
>
> ```
> var args = new Array();
> args.push(adwhirlCode);
> args.push(position);
> _init_func(args);
> ```

#### Part 2 - The Java Code

Now, peek at **project/android/NativeTest.java**.

```
public static void showAlert(final String title, final String message)
{
    [...]
}
```

There's the underlying Java implementation for **showAlert()**. Notice how `showAlert()` takes two Strings as its arguments? That's why that JNI call above looked the way it did.

```
androidAlert = nme.JNI.createStaticMethod("NativeTest", "showAlert", "(Ljava/lang/String;Ljava/lang/String;)V", true);
```

#### More on JNI

It turns out that **JNI is serving the same purpose that ExternalInterface.cpp did for iOS**. It's the glue that connects native code to Haxe. It just happens at the Haxe level, rather than being in a separate file.

Getting the JNI syntax correct is a [topic in itself](https://www.stencyl.com/help/view/jni-guide/).

#### Recap
To recap, an Android extension consists of 2 parts.

* Haxe source that fetches function pointers to native code through JNI.
* The Java source files.

This is summarized in the following graphic.

![stencyl-levels-of-abstraction](https://static.stencyl.com/pedia2/chapter-d/AbstractionAndroid.png)

Now, we'll look at a few more topics.

## External Libraries

If you need to include an External Library, you can specify which libraries you wish to include inside **include.xml** (in some extensions, it's called **include.nmml**).

#### For iOS Extensions

In this example, we're importing a system framework (iAd) using the `<dependency>` tag.

> **Aside:** `<ndll>` is used to import the compiled form of your iOS extension into any projects that use it.

```
<?xml version="1.0" encoding="utf-8"?>
<project>
    <section if="ios">
        <ndll name="ads"/>
        <dependency name="iAd.framework" />
    </section>
</project>
```

In this example, we're importing a 3rd party framework that is placed under the **frameworks/** subfolder of the extension. Note that the attribute name is **path**, rather than **name** in the example above.

```
<?xml version="1.0" encoding="utf-8"?>
<project>
    <section if="ios">
        <ndll name="ads"/>
        <dependency path="frameworks/Tapdaq.framework" />
    </section>
</project>
```

#### For Android Extensions

If your Android extension includes just Java source and no libraries, just specify the (relative) path to the folder containing the source. For example, if your Java source was located under **project/android**, you'd do this:

```
<?xml version="1.0" encoding="utf-8"?>
<extension>
  <section if="android">
    <java path="project/android"/>
  </section>
</extension>
```

If your Android extension needs to import libraries, it gets more complicated.

```
<?xml version="1.0" encoding="utf-8"?>
<extension>
  <section if="android">
    <dependency name="tapdaq" path="dependencies/tapdaq"/>
    <android extension="com.byrobin.tapdaq.TapdaqEx"/>
  </section>
</extension>
```

`<dependency>` specifies what folder contains the sources and libraries for your Android extension. In this example, those are located at **dependencies/tapdaq**. [(See Example)](https://github.com/byrobingames/tapdaq/tree/master/dependencies/tapdaq)

Within that folder are two subfolders and a few extra files. One subfolder is a **libs* folder that contains the tapdaq.jar library we want to import.

`<android>` is used to specify the path to the Java sources for the extension (the portion that *you* write). The value for the `extension` attribute is the package name for your sources. You place the sources under **[DEPENDENCY]/src/** where [DEPENDENCY] is the folder specified in the `<dependency>` tag.

#### OpenFL Reference

This [page](https://lime.software/docs/project-files/xml-format/) covers the purpose of each `<dependency>`, `<ios>`, and `<android>` in more detail.

Documentation is pretty thin for this, so our recommendation is to check out [existing extensions](https://github.com/byrobingames) for examples of how to lay the files in your extension.

## Building from the Command Line (iOS Only)

If you make a change to an iOS extension, you must **compile** the extension, which will output libraries to its **ndll** directory. This step is not required for Android.

To compile the extension, **run the `build` script** (located under the **project/** subdirectory of an extension). This compiles the iOS source and generates the .a libraries.

![build-script](https://static.stencyl.com/pedia2/chapter-d/build-script.png)

For example, if you wanted to build the test-native extension, you would **cd** to **[WORKSPACE]/engine-extensions/test-native/project** and then run **./build**.

```
cd [WORKSPACE]/engine-extensions/test-native/project
./build
```

> **Tip:** If you get errors about Neko or Haxe not being recognized, re-read the Setup section of this doc.

## Editing project/Build.xml (iOS only)

You must edit **project/Build.xml** before compiling your iOS extension. **project/Build.xml** controls the name of the outputted library files and also serves to specify what .mm (Objective-C) files to include (and compile).

Our recommendation is to view existing examples to figure out what to edit - it's a lot easier than trying to type it up from scratch.

For example, take [this sample](https://github.com/byrobingames/tapdaq/blob/master/project/Build.xml) from an extension for Tapdaq ads.

Then, you'd do two things:

1. Search for **mm**. This is where you'd specify all the .mm source files for the extension.

  ```
  <file name="ios/TapdaqEx.mm"/>
  ```

2. Search for `tapdaq` and replace each instance with the name of your extension (in lower case).

  * Line 56 contains `<target id="NDLL" output="${name_prefix}tapdaq${name_extra}" tool="linker" toolid="${ndll-tool}">`
  * Line 65 contains `<vflag name="-framework" value="Tapdaq" />`

## Sending Data back from Native Code to Haxe

A big part of Stencyl's ease of use comes in the form of [Events](https://www.stencyl.com/help/view/native-events/). As a developer, it's more convenient to be **automatically notified** that something has happened, versus having to constantly check if that something has happened.

To implement Events for your extensions, you would need to know how to get the Objective-C (or Java) code to send notifications back to Haxe. For example, if the player completed an in-app purchase, you'd want to inform the player if the purchase succeeded and do something in-game in response to that.

[Learn how to implement Events for iOS / Android](https://www.stencyl.com/help/view/native-events/).

## Tips

#### Android (Java) - Getting the Main Class

If you need to refer to the "main class" or "Activity" in Android speak, call `GameActivity.getInstance()`.

```
import org.haxe.nme.GameActivity;
[...]
GameActivity.getInstance()
```

#### Android (Java) - Running code on UI Thread

By default, code runs on the main thread rather than the UI thread. This can pose problems if you need to change the UI (e.g. and can lead to crashes or unexpected behavior.

If you do need to alter the UI, like adding stuff to the screen, you should do something much like `SwingUtilities.invokeLater()`:

```
GameActivity.getInstance().runOnUiThread(new Runnable()
{
    public void run()
    {
    }
});
```

> **Tip:** There's another method called **runOnHaxeThread** that does the opposite - guarantees running on the Haxe/main thread.

repository: Stencyl/stencylpedia

gha_language: Batchfile

repo_name: Stencyl/stencylpedia


text:
---
id: getting-started
title: Getting Started
sidebar_label: Getting Started
---

Celerity is a high-level C++17 API and runtime environment that aims to bring
the power and ease of use of [SYCL](https://www.khronos.org/sycl/) to
distributed-memory accelerator clusters.

> If you want to get your hands dirty right away, move on to the
> [Installation](installation.md) guide.

## Transparently Scale Your Applications

Celerity allows you to write highly parallel applications that can be run on a
cluster of accelerator nodes. It focuses on providing a way of scaling
applications to many nodes **without having to be an expert in cluster
programming**. In fact, the Celerity API does not make it apparent that a
program is (potentially) running on many nodes at all: There is no notion of
_ranks_; **partitioning of work and data is taken care of transparently behind the
scenes**. This lets you focus on your actual work, without having to concern
yourself with the complexities of modern distributed memory cluster programming.

### A Word of Caution

While ease of use is one of Celerity's main goals, simplicity can only go so far
without sacrificing considerable performance. **Proficiency in modern C++ as
well as at least a rough understanding of how accelerator (GPU) programming
differs from parallel CPU programming is required** to make efficient use of
Celerity. Additionally, you will require a good understanding of the algorithms
and techniques you intend to implement using Celerity in order for the runtime
system to be able to run it on a cluster both correctly and in an efficient
manner.

## Built on a Strong Foundation

Celerity is built on top of [SYCL](https://www.khronos.org/sycl/), an
open-standard high-level C++ embedded domain specific language for programming
accelerators. SYCL provides a great API that hits a sweet spot between
expressiveness and power as well as ease of use, making it the perfect starting
point for Celerity: We set out to find the **minimal set of API extensions**
required to bring the SYCL API to distributed memory clusters - thus making it
relatively **easy to migrate an existing SYCL application to Celerity**. If you
don't have any experience with SYCL, don't worry, as we will introduce the most
important concepts along the way.

### Points of Divergence

While it is one of Celerity's [Core Principles](core-principles.md) to stick as
closely to SYCL as possible, **the Celerity API is neither a super- nor subset
of the SYCL API**: On one hand certain SYCL features, such as SYCL 2020's
unified shared memory (USM), are inherently unsuitable for distributed memory
execution and can therefore not be supported by Celerity. On the other hand,
certain high-performance computing (HPC) features such as [Collective Host
Tasks](host-tasks.md#experimental-collective-host-tasks) are required to make
Celerity work at scale.

> Starting with Celerity 0.3.0, most supported SYCL features are made available
> through the `celerity::` namespace, in addition to the `sycl::` namespace.
> When in doubt, we recommend sticking to the former.

## Further Reading

If this piqued your interest and you would like to try it for yourself, check
out the [Installation](installation.md) section on how to build and install
Celerity. For a complete example of how to set up a Celerity application from
start to finish, see the [Tutorial](tutorial.md).

For more information on the overall Celerity API as well as the driving
principles behind its design, please see our Celerity in-depth
[Overview](overview.md) section.

repository: celerity/celerity-runtime

repo_name: celerity/celerity-runtime


text:
### Project Overview

 great insights for python learning

### Learnings from the project

 I tried learning python and this is best mostly for beginners

### Approach taken to solve the problem

 I took help from this course only for completing project

### Challenges faced

 only one challenge
for some time i need to visit other site for complete understanding
please give reference to better one

### Additional pointers

 increase the length of content
It may increases time of content completing
but it will give a beginner a great user experience ,
for all who willing to learn seriously


text:
---
title: Using Cloudflare for Dynamic DNS on Unifi
tags:
- unifi
- cloudflare
summary: Using Cloudflare for Dynamic DNS on Unifi OS without any additional local
  components
date: 2022-05-28 12:13
slug: using-cloudflare-for-dynamic-dns-on-unifi
---
I have recently been revisiting my home server setup and moving more "core" tools onto Raspberry Pis as opposed to my ageing HP MicroServer. As part of this, I had been checking if the way I had things set up was still a good way to go.

Up until last week I was using [ddclient](https://github.com/ddclient/ddclient) for updating a DNS record in Cloudflare with my home IP address for the (now rare) cases where I need remote access back into my home network. I had always found it strange that the Dynamic DNS options in Unifi did not support Cloudflare.

Now there is the [Cloudflare DDNS for UniFi OS](https://github.com/willswire/unifi-cloudflare-ddns) project.

>  Cloudflare Worker script that exposes a UniFi-compatible DDNS API to dynamically update the IP address of a DNS A record.

With this I can deploy a (free) Cloudflare worker that the Unifi OS can call to update my DNS record without requiring to run additional service containers on my local network.

I did initially have some problems setting this up (which have now fixed by a PR), and this blog post was very helpful in providing commands that could be ran from the USG-3P to force Dynamic DNS updates while I was testing changes: [Configuring Ubiquiti UniFi USG to use Namecheap DDNS](https://daltonflanagan.com/configuring-ubiquiti-unifi-usg-for-namecheap-ddns/).

extension: markdown


text:
# Honey Garlic Slow Cooker Ribs

## Overview

- Yield:
- Prep Time:
- Cook Time:
- Total Time:

## Ingredients

## Method

## References and Acknowledgments

[Honey Garlic Slow Cooker Ribs](https://tasty.co/recipe/honey-garlic-slow-cooker-ribs)

## Tags


text:
# Visionaries

Cloud Innovation Center at RMIT University.
Team Visionaries

**Problem Statement:**
	How might we inform building managers and engineers about asset status,  potential faults, and scheduled tasks as an automated summary report via a voice assistant.

**Solution:**
   An AI powered voice assistant would read a daily summary report and provide updates of the day. An engineer would receive information/status update of any asset in the building on interactions with the Q&A voice assistant. The capabilities of the bot can be extended to visualizing sensor data, using push notifications to alert for any asset failure thus contributing to efficient resource planning.

**Features:**

   - Easy access to real-time building data using voice commands thus saving a lot of time
   - Avoid repetitive manual tasks and spend more time on important task
   - Easier to assess the construction site and monitor the status of the systems using mobile app dashboard (future scope)
   - Mitigate future risks and improve workplace safety through predictive maintenance and forecasting

**Installation Steps**

   - Login to https://developer.amazon.com/alexa/console/ask
   - Click on “Create Skill”
   - Select Skill Type as “Custom” and host as “Alexa-hosted (Python)”
   - Go to the “Code” tab and replace all the files with ours. Make certain changes that suits to your AWS account configurations
   - Test the Alexa Skill from the “Test”
   - For beta testing and release, go to Distribution and follow the necessary steps.

repository: rmit-cyber-ready-cic/Visionaries

repo_name: rmit-cyber-ready-cic/Visionaries