text:
Dockerfiles for Unreal Engine 4
===============================

**IMPORTANT LEGAL NOTICE: the Docker images produced by the code in this repository contain the UE4 Engine Tools in both source code and object code form. As per Section 1A of the [Unreal Engine EULA](https://www.unrealengine.com/eula), Engine Licensees are prohibited from public distribution of the Engine Tools unless such distribution takes place via the Unreal Marketplace or a fork of the Epic Games UE4 GitHub repository. [Public distribution of the built images via an openly accessible Docker Registry (e.g. Docker Hub) is a direct violation of the license terms.](https://www.unrealengine.com/eula) It is your responsibility to ensure that any private distribution to other Engine Licensees (such as via an organisation's internal Docker Registry) complies with the terms of the Unreal Engine EULA.**

This repository contains a set of Dockerfiles and an accompanying Python build script that allow you to build Docker images for Epic Games' [Unreal Engine 4](https://www.unrealengine.com/). Key features include:

- The images contain a full source build of the Engine and are suitable for use in a Continuous Integration (CI) pipeline.
- **Both Windows containers and Linux containers are supported.**
- When building UE4 version 4.19.0 or newer, [conan-ue4cli](https://github.com/adamrehn/conan-ue4cli) support is also built by default, although this behaviour can be disabled by using the `--no-ue4cli` flag when invoking the build script.

For a detailed discussion on how the build process works, see [the accompanying article on my website](http://adamrehn.com/articles/building-docker-images-for-unreal-engine-4).

## Contents

- [Requirements](#requirements)
- [Build script usage](#build-script-usage)
    - [Building images](#building-images)
    - [Building Linux container images under Windows](#building-linux-container-images-under-windows)
    - [Performing a dry run](#performing-a-dry-run)
    - [Upgrading from a previous version](#upgrading-from-a-previous-version)
- [Windows `hcsshim` timeout issues](#windows-hcsshim-timeout-issues)

## Requirements

The common requirements for both Windows and Linux containers are:

- A minimum of 100GB of available disk space
- A minimum of 8GB of available memory
- [Python](https://www.python.org/) 3.x with `pip`
- The dependency packages listed in [requirements.txt](./requirements.txt), which can be installed by running `pip3 install -r requirements.txt`

Building **Windows containers** also requires:

- Windows 10 Pro/Enterprise or Windows Server 2016
- [Docker For Windows](https://www.docker.com/docker-windows) (under Windows 10) or [Docker EE For Windows Server](https://www.docker.com/docker-windows-server) (under Windows Server 2016)
- Under Windows 10, the Docker daemon must be configured to use Windows containers instead of Linux containers
- The Docker daemon must be configured to increase the maximum container disk size from the default 20GB limit by following [the instructions provided by Microsoft](https://docs.microsoft.com/en-us/visualstudio/install/build-tools-container#step-4-expand-maximum-container-disk-size). The 120GB limit specified in the instructions is sufficient.

Building **Linux containers** also requires:

- Windows 10 Pro/Enterprise, Linux or macOS
- [Docker For Windows](https://www.docker.com/docker-windows) (under Windows 10), [Docker CE](https://www.docker.com/community-edition) (under Linux) or [Docker For Mac](https://www.docker.com/docker-mac) (under macOS)
- Under Windows 10, the Docker daemon must be configured to use Linux containers instead of Windows containers
- Under Windows 10 and macOS, Docker must be configured in the "Advanced" settings pane to allocate 8GB of memory and a maximum disk image size of 120GB

## Build script usage

### Building images

First, ensure you have installed the dependencies of the Python build script by running `pip3 install -r requirements.txt`. (You may need to prefix this command with `sudo` under Linux and macOS.)

Then, simply invoke the build script by specifying the UE4 release that you would like to build using full [semver](https://semver.org/) version syntax. For example, to build Unreal Engine 4.19.1:

```
python3 build.py 4.19.1
```

*(Note that you may need to replace the command `python3` with `python` under Windows.)*

You will be prompted for the Git credentials to be used when cloning the UE4 GitHub repository (this will be the GitHub username and password you normally use when cloning <https://github.com/EpicGames/UnrealEngine>.) The build process will then start automatically, displaying progress output from each of the `docker build` commands that are being run.

Once the build process is complete, you will have five new Docker images on your system (where `RELEASE` is the release that you specified when invoking the build script):

- `adamrehn/ue4-build-prerequisites:latest` - this contains the build prerequisites common to all Engine versions and should be kept in order to speed up subsequent builds of additional Engine versions.
- `adamrehn/ue4-source:RELEASE` - this contains the cloned source code for UE4. This image is separated from the `ue4-build` image to isolate the effects of changing environment variables related to git credentials, so that they don't interfere with the build cache for the subsequent steps.
- `adamrehn/ue4-build:RELEASE` - this contains the source build for UE4.
- `adamrehn/conan-ue4cli:RELEASE` - this extends the source build with [conan-ue4cli](https://github.com/adamrehn/conan-ue4cli) support for building Conan packages that are compatible with UE4. This image will only be built for UE4 versions >= 4.19.0, which is the minimum Engine version required by ue4cli. You can disable the build for this image by specifying `--no-ue4cli` when you run the build script.
- `adamrehn/ue4-package:RELEASE` - this extends the `conan-ue4cli` image and is designed for packaging Shipping builds of UE4 projects. Note that the image simply pre-builds components needed for packaging in order to speed up subsequent build time, and is not required in order to package projects (both the `ue4-build` and `conan-ue4cli` images can be used to package projects, albeit with longer build times.) This image will only be built if the `conan-ue4cli` image is built. You can disable the build for this image by specifying `--no-package` when you run the build script.

### Building Linux container images under Windows

By default, Windows container images are built when running the build script under Windows. To build Linux container images instead, simply specify the `--linux` flag when invoking the build script.

### Performing a dry run

If you would like to see what `docker build` commands will be run without actually building anything, you can specify the `--dry-run` flag when invoking the build script. Execution will proceed as normal, except that all `docker build` commands will be printed to standard output instead of being executed as child processes.

### Upgrading from a previous version

When upgrading to a newer version of the code in this repository, be sure to specify the `--rebuild` flag when invoking the build script. This will ensure all images are rebuilt using the updated Dockerfiles.

## Windows `hcsshim` timeout issues

Recent versions of Docker For Windows may sometimes encounter the error [hcsshim: timeout waiting for notification extra info](https://github.com/Microsoft/hcsshim/issues/152) when building or running Windows containers. At the time of writing, Microsoft have stated that they are aware of the problem, but an official fix is yet to be released.

As a workaround until a proper fix is issued, it seems that altering the memory limit for containers between subsequent invocations of the `docker` command can reduce the frequency with which this error occurs. (Changing the memory limit when using Hyper-V isolation likely forces Docker to provision a new Hyper-V VM, preventing it from re-using an existing one that has become unresponsive.) **Please note that this workaround has been devised based on my own testing under Windows 10 and may not hold true for Windows Server 2016.**

To enable the workaround, specify the `--random-memory` flag when invoking the build script. This will set the container memory limit to a random value between 8GB and 10GB when the build script starts. If a build fails with the `hcsshim` timeout error, simply re-run the build script and in most cases the build will continue successfully, even if only for a short while. Restarting the Docker daemon may also help.

Note that in some cases, using a memory limit that is not a multiple of 4GB can cause UnrealBuildTool to crash with an error stating *"The process cannot access the file because it is being used by another process."* If this happens, simply run the build script again without the `--random-memory` flag. If the access error occurs when using the default memory limit, this likely indicates that Windows is unable to allocate the full 8GB to the container. Rebooting the host system may help to alleviate this issue.


text:
# Installing
* Debian/Ubuntu:
```
$ sudo apt-get install tasksh
```

# Disclaimer during ongoing development

The development branch is a work in progress and may not pass all quality tests,
therefore it may harm your data. While we welcome bug reports from the
development branch, we do not guarantee proper or timely fixes.

- Make proper backups.
- Broken functionality may arise from ongoing development work.
- Be aware that using the development branch involves risks.

---

Thank you for taking a look at tasksh!!

---

Tasksh is released under the MIT license. For details check the LICENSE file.

# Important note
When cloning this from the repo to build from source make sure you `git clone --recursive` to get all required submodules.

license: MIT

repository: taDachs/taskshell

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: taDachs/taskshell


text:
# Frontfy CLI

**Frontfy-cli** aims to generate a new [Frontfy](https://github.com/owInteractive/frontfy) project already configured and with the possibility of creating pages, components and directives.

## Installation

Prerequisites: Node.js (>=8.x), npm version 3+ and Git.

```sh
$ npm i -g frontfy-cli
```

## Usage

```sh
frontfy <command>
```

## Commands

Commands currently available:

### Init

> The init command is used to create a new, clean and configured Frontfy project.

```sh
$ frontfy init
```

The init method contains some questions after calling:

#### Questions about the project

| Question | Description |
| ------------- |-----|
| How would you like to name the project? | This command has a prefix **front.** and a suffix **.com.br**. So if the input is "example" the result for this question is **front.example.com.br** |
| What technology do you want to use? | The choices are [NodeJS](https://github.com/owInteractive/frontfy) or [PHP](https://github.com/owInteractive/frontfy-php) |

#### Questions about the repository

| Question | Description |
| ------------- |-----|
| Do you like to create a repository? | The choices are Bitbucket, Github or None. |
| Enter with your Client ID/Key: | To authorize the repository creation at Bitbucket we need your OAuth Client ID/Key. See more in the section **Configuration - OAuth authentication**. |
| Enter with your Client Secret: | To authorize the repository creation at Bitbucket we need your OAuth Client Secret. See more in the section **Configuration - OAuth authentication**. |
| Who is the owner of the project? (Only in Bitbucket) | Project owner on Bitbucket. Default is *owinteractive* the owner of Frontfy. |

#### Run the project
| Question | Description |
| ------------- |-----|
| Do you like to run the project? | (Y/n) |

### Generate

> The generate command is used to generate a new component, directive or page. This commands only works in the NodeJS project for now.

```sh
$ frontfy generate
```

or

```sh
$ frontfy generate <type> <name>
```

The first example will have some questions, such as what you want to generate and the name of the item being generated. The second example is a syntax sugar for the first. You will already pass the type (component, directive or page) and the name of the item directly.

#### Component

Run the command below:

```sh
$ frontfy generate component Message
```

When generating a component the same is created inside *src/assets/js/components*.

#### Directive

Run the command below:

```sh
$ frontfy generate directive date-convert
```

When generating a directive it is created in *src/assets/js/directives*.

#### Page

Run the command below:

```sh
$ frontfy generate page about
```

When generating a new page it is created in *src/views/site*. The page is created using the [EJS](https://ejs.co/) template.
 A new route to this page is created and added to the express router. So if you generate a page called "about", you'll already be able to access it in your browser. Example: http://localhost:3301/about.

## Configuration

### OAuth authentication

#### Bitbucket

To authorize the Bitbucket we need your OAuth Client Key and Client Secret. Follow the steps below:

1) Go to Bitbucket (https://bitbucket.org);
2) Click on your profile picture;
3) Click on Bitbucket settings;
4) Click on OAuth;
5) Click on Add consumer;
6) Fill the fields:
    * Name: frontfy
    * Callback URL: http://localhost:3301/oauth-callback
    * Permissions: check repositories options write and admin
7) Click on Save to get your key and secret.

#### Github
To authorize the Github we need your OAuth Client ID and Client Secret. Follow the steps below:

1) Go to Github (https://github.com);
2) Click on your profile picture;
3) Click on Settings;
4) Click on Developer Settings;
5) Click on Register a new aplication;
6) Fill the fields:
    * Application name: frontfy
    * Homepage URL: http://localhost:3301
    * Authorization callback URL: http://localhost:3301/oauth-callback
7) Click on Register application to get your key and secret.

### Frontfy configurations

See the documentation in [Frontfy repository](https://github.com/owInteractive/frontfy).

License
----

[MIT](http://opensource.org/licenses/MIT)

repository: owInteractive/frontfy-cli

repo_name: owInteractive/frontfy-cli


text:
JSqueak -- Java implementation of the Squeak Smalltalk Virtual Machine
----------------------------------------------------------------------

This is a fork of JSqueak, a Java  implementation of the Squeak Smalltalk virtual machine first born in 2008

This repository is maintained by Giovanni Giorgi<EMAIL_ADDRESS>

This repository has been forked from repository  of Victor Rodriguez<EMAIL_ADDRESS>and merged with work from Jan Tomsa<EMAIL_ADDRESS>and the potato fork [3] taken from https://svn.code.sf.net/p/potatovm/code/trunk/

Jump Start
------------
A special modified test-image1 is provided for unit testing (look at the zip inside test_images folder)
This image has been altered via Squeak22.exe to provide an hook to a special bootstrap class.
The Special bootstrap class is used for running a bunch of test at boot.
The entry point is
 SystemDictionary << processStartUpList
 Class DisplayScreen << startUp

## Requirements
JDK 1.6.33 64bit or better.
Garbage Collector GC1 is the default choice for low latency.
Suggested at least 4GB of RAM, and a 64-bit Operating System.
Tested on MS Windows, and MAC OS X, should work without problem under Linux too.

Java Inteoperability
----------------------
There is an Alpha stage java interoperability.
The new primitive javaNew (number 1993) is able to create a java object instance, so you can write something like

```smalltalk
(Object javaNew: 'java.lang.Object') hashCode asString
```

Or try out a simple test class:

```smalltalk
(Object javaNew: 'org.squeak.potato.javainterop.Tester')
				test: 1 two: 2
```

At the time of writing you can pass easily String, Integers and java object back and forward.

## Debug support
A strong debug support is provided.
Use
 -Djsqueak.debug.flag=true
to enable it
The breakPointMonitor vatiable defined in VM can set a list of selector to trigger the debug sniper.

DOCUMENTATION
--------------
See http://potatovm.blogspot.it/ for two articles on potato VM internals.

LICENSE
-------------

JSqueak was released under the MIT license (see the announcement[1] but also [2]).
Any original code released on this repository is also released under
the MIT license.

GOALS
-------------
At the time of writing the first goal is to do minimal Java interoperability and to enable image saving in a custom format (at least)
Secondary Goal is to be able to boot Squeak 2.2 image and then Squeak 3.x image (very far away target, anyway).

Documentation
-----------------
Blue Book: http://stephane.ducasse.free.fr/FreeBooks/BlueBook/Bluebook.pdf

Change History
---------------
Please see ChangeLog for important release notes.

Bugs
--------
See GitHub tracker

[1] http://www.nabble.com/-squeak-dev--JSqueak%2C-the-erstwhile-Potato%2C-is-out%21-p18045925.html
[2] http://news.squeak.org/2008/06/21/jsqueak-smalltalk-interpreter-written-in-java/
[3] http://news.squeak.org/2008/07/07/potato-version-of-jsqueak-from-hpi/

```emacs
Local Variables:
mode: markdown
mode: visual-line
coding: utf-8
End:
```

repository: curtcox/jsqueak

repo_name: curtcox/jsqueak


text:
[Frequency distribution] of States/UTs for fixing the number of districts to be sampled.

📦 [Node.js](https://www.npmjs.com/package/@ifct2017/frequencydistribution),
📜 [Files](https://unpkg.com/@ifct2017/frequencydistribution/).

> This is part of package [ifct2017].

> Online database: [ifct2017.github.io].

```javascript
const frequencyDistribution = require('@ifct2017/frequencydistribution');
// frequencyDistribution(districts)
// → {districts, states, selected, sampled} if found, null otherwise

frequencyDistribution(2);
frequencyDistribution(5);
// { districts: '1-5', states: 9, selected: 1, sampled: 9 }

frequencyDistribution(32);
frequencyDistribution(37);
// { districts: '31-40', states: 4, selected: 5, sampled: 20 }
```

```javascript
// Additional methods:
frequencyDistribution.load() // → corpus
frequencyDistribution.sql([table], [options]) // → sql statements
frequencyDistribution.csv() // → path of csv file
```

[![](https://i.imgur.com/D5UYmbD.jpg)](http://ifct2017.com/)

[![ORG](https://img.shields.io/badge/org-ifct2017-green?logo=Org)](https://ifct2017.github.io)
[![DOI](https://zenodo.org/badge/132989662.svg)](https://zenodo.org/badge/latestdoi/132989662)

> Data was obtained from the book [Indian Food Composition Tables 2017].

> Food composition values were measured by [National Institute of Nutrition, Hyderabad].

[ifct2017]: https://www.npmjs.com/package/ifct2017
[Indian Food Composition Tables 2017]: http://ifct2017.com/
[Frequency distribution]: https://github.com/ifct2017/frequencydistribution/blob/master/index.csv
[ifct2017.github.io]: https://ifct2017.github.io
[National Institute of Nutrition, Hyderabad]: https://www.nin.res.in/

gha_language: JavaScript

gha_license_id: MIT


text:
# Sennheiser Momentum 2.0 Wireless
See [usage instructions](https://github.com/jaakkopasanen/AutoEq#usage) for more options and info.

### Parametric EQs
In case of using parametric equalizer, apply preamp of **-7.5dB** and build filters manually
with these parameters. The first 5 filters can be used independently.
When using independent subset of filters, apply preamp of **-7.2dB**.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 82 Hz    | 0.57 | -6.3 dB |
| Peaking | 1269 Hz  | 0.84 | -4.6 dB |
| Peaking | 3772 Hz  | 2.2  | 5.9 dB  |
| Peaking | 7563 Hz  | 1.41 | 5.6 dB  |
| Peaking | 18528 Hz | 0.45 | 6.4 dB  |
| Peaking | 17 Hz    | 1.03 | 5.1 dB  |
| Peaking | 42 Hz    | 2    | -2.9 dB |
| Peaking | 370 Hz   | 4.49 | 1.7 dB  |
| Peaking | 5064 Hz  | 8.35 | -6.0 dB |
| Peaking | 5170 Hz  | 2.81 | 2.6 dB  |

### Fixed Band EQs
In case of using fixed band (also called graphic) equalizer, apply preamp of **-7.7dB**
(if available) and set gains manually with these parameters.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 31 Hz    | 1.41 | -0.4 dB |
| Peaking | 62 Hz    | 1.41 | -6.3 dB |
| Peaking | 125 Hz   | 1.41 | -3.9 dB |
| Peaking | 250 Hz   | 1.41 | -1.5 dB |
| Peaking | 500 Hz   | 1.41 | 0.3 dB  |
| Peaking | 1000 Hz  | 1.41 | -4.3 dB |
| Peaking | 2000 Hz  | 1.41 | -2.8 dB |
| Peaking | 4000 Hz  | 1.41 | 5.3 dB  |
| Peaking | 8000 Hz  | 1.41 | 5.4 dB  |
| Peaking | 16000 Hz | 1.41 | 6.9 dB  |

### Graphs
![](./Sennheiser%20Momentum%202.0%20Wireless.png)

repository: cpiscos/AutoEq

path: /results/crinacle/gras_43ag-7_harman_over-ear_2018/Sennheiser Momentum 2.0 Wireless/README.md

repo_name: cpiscos/AutoEq


text:
# General Information

This is general information and documentation for installing new instance via current architecture.

1. [Setup New Instances](https://github.com/coronatorid/contooling/blob/main/general%2FSETUP.md)

repository: coronatorid/contooling

branch_name: refs/heads/main

gha_language: Shell

repo_name: coronatorid/contooling


text:
# minishell

[![jaeskim's 42Project Score](https://badge42.herokuapp.com/api/project/jserrano/minishell)](https://github.com/JaeSeoKim/badge42)

![logo](https://i.ibb.co/N6kGJWg/minishell-logo.png)

### Index 📋
You're sections headers will be used to reference location of destination.

- [Description :memo:](#description)
    - [Scheme :twisted_rightwards_arrows:](#scheme)
	- [Developed commands 🚧](#developed-commands)
	- [Allowed Functions :white_check_mark:](#allowed-functions)
- [How To Use 📦](#how-to-use)
- [References 📌](#references)
- [License 📄](#license)
- [Author Info  ✒](#author-info)

---

## Description
The goal of this project is to create a simple shell.  You are going to learn a lot about processes and file descriptors.

---

### Scheme
![Scheme](minishell.png)

[Back To The Top](#minishell)

---

### Developed commands
```bash
- Find and launch the appropriate executable.
- Builtins:
    - echo (-n flag included)
    - cd (with absolute and relative path)
    - pwd
    - export
    - unset
    - env
    - exit
- ; will have to separate the commands on the command line.
- Redirects >, “>>” y < should work as in bash, except in fd aggregations.
- Environment variables ($ followed by characters) should work like in bash.
- Pipes | should work like in bash.
- $? it should work like in bash.
- ctrl-C, ctrl-D y ctrl-\ should show the same result as in the bash.
```

[Back To The Top](#minishell)

---

### Allowed Functions
- **malloc**
- **free**
- **write**
- **open**
- **read**
- **close**
- **fork** = [Creates a child process.](https://man7.org/linux/man-pages/man2/fork.2.html)
- **wait, waitpid**  = [Stops the parent process until the child process exit.](https://man7.org/linux/man-pages/man2/waitid.2.html)
- **wait3, wait4** = [Are similar to waitpid, but additionally return resource usage information about the child.](https://man7.org/linux/man-pages/man2/wait3.2.html)
- **signal** = [Sets a function to handle a signal.](https://man7.org/linux/man-pages/man2/signal.2.html)
- **kill** = [Sends a signal to a process or a group of processes.](https://man7.org/linux/man-pages/man2/kill.2.html)
- **exit** = [Terminates a process immediately, special handle for child processes.](https://www.tutorialspoint.com/c_standard_library/c_function_exit.htm)
- **getcwd** = [Saves the pathname of your current working directory in a string.](https://man7.org/linux/man-pages/man2/getcwd.2.html)
- **chdir** = [Changes your current working directory.](https://man7.org/linux/man-pages/man2/chdir.2.html)
- **stat, lstat, fstat** = [Returns information about a file.](https://man7.org/linux/man-pages/man2/stat.2.html)
  - stat = Standar.
  - lstat = For symbolic links.
  - fstat = Gets the file from a file descriptor.
- **execve** = [Executes a program referred by a variable.](https://man7.org/linux/man-pages/man2/execve.2.html)
- **dup** = [Creates a copy of a file descriptor using the lowest numbereded unused descriptor.](https://man7.org/linux/man-pages/man2/dup.2.html)
- **dup2** = [Creates a copy of a file descriptor using the descriptor number given by the user.](https://man7.org/linux/man-pages/man2/dup.2.html)
- **pipe** = [It's used to create inter-process communication.](https://man7.org/linux/man-pages/man2/pipe.2.html)
- **opendir** = [Opens a directory stream.](https://pubs.opengroup.org/onlinepubs/009695399/functions/opendir.html)
- **readdir** = [Returns a pointer to a dirent structure representing the next directory entry in the directory stream.](https://www.man7.org/linux/man-pages/man3/readdir.3.html)
- **closedir** = [Closes the directory stream.](https://linux.die.net/man/3/closedir)
- **strerror** = [Returns an error message.](https://www.tutorialspoint.com/c_standard_library/c_function_strerror.htm)
- **errno** = [Number of last error, its a variable.](https://www.youtube.com/watch?v=IZiUT-ipnj0&ab_channel=JacobSorber)

[Back To The Top](#minishell)

---

## How To Use
> Deployment
```shell
git clone https://github.com/j53rran0/minishell.git
make && ./minishell
```

## References
- [Variables de entorno](https://www.youtube.com/watch?v=ZX58AHhXpyA)
- [Sintaxis del shell](https://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html)
- [Evaluation](https://github.com/Binary-Hackers/42_Corrections/blob/master/00_Projects/01_Unix/minishell/00.pdf)

### Functions
- [fork: parte 1](https://www.youtube.com/watch?v=VwjP-KFuZCM)
- [fork: parte 2](https://www.youtube.com/watch?v=Dt9z_ohQWHI)
- [fork & pipe](https://www.youtube.com/watch?v=oxWxcYoJJdM&ab_channel=WhileTrueThenDream)
- [signal: parte 1](https://www.youtube.com/watch?v=rNGlwqHpoGw)
- [signal: parte 2](https://www.youtube.com/watch?v=_Ks8q1KQ2Eg&ab_channel=WhileTrueThenDream)
- [exec](https://www.youtube.com/watch?v=yIe_9lqng2I)
- [stat](https://www.youtube.com/watch?v=LERSkW_pLBs)
- [readdir & opendir](https://www.youtube.com/watch?v=vbAfIGR_5XM)
- [pipe](https://www.geeksforgeeks.org/pipe-system-call/)
- [wait](https://www.geeksforgeeks.org/wait-system-call-c/)
- [dup & dup2](https://www.geeksforgeeks.org/dup-dup2-linux-system-call/)

[Back To The Top](#minishell)

---

## License
MIT License

Copyright [2020] [Paris Martínez Ruiz] [Jaime Serrano González]

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.

[Back To The Top](#minishell)

---

## Author Info

### Paris
- Twitter - [@TroyaParisde](https://twitter.com/TroyaParisde)
- Instagram - [@parisdetroya42](https://instagram.com/parisdetroya42)
- 42 Madrid - [parmarti](https://profile.intra.42.fr/users/parmarti)

### Jaime
- 42 Madrid - [Jserrano](https://profile.intra.42.fr/users/jserrano)

[Back To The Top](#minishell)

repository: eljommys/minishell

repo_name: eljommys/minishell


text:
---
slug: "/jam-stack"
date: "2019-12-01"
title: "The JAMstack"
---

A modern architecture — Create fast and secure sites and dynamic apps with JavaScript, APIs, and prerendered Markup, served without web servers. The JAMstack is not about specific technologies. It’s a new way of building websites and apps that delivers better performance, higher security, lower cost of scaling, and a better developer experience.

## What is the JAMstack?

### JavaScript
Any dynamic programming during the request/response cycle is handled by JavaScript, running entirely on the client. This could be any frontend framework, library, or even vanilla JavaScript.

### APIs
All server-side processes or database actions are abstracted into reusable APIs, accessed over HTTPS with JavaScript. These can be custom-built or leverage third-party services.

### Markup
Templated markup should be prebuilt at deploy time, usually using a site generator for content sites, or a build tool for web apps.


text:
# Excemel: Better XML for JRuby

[![Build Status](https://secure.travis-ci.org/integrallis/excemel.png?branch=master)](http://travis-ci.org/integrallis/excemel)
[![Gem Version](https://badge.fury.io/rb/excemel.png)](http://badge.fury.io/rb/excemel)
[![Dependency Status](https://gemnasium.com/integrallis/excemel.png)](https://gemnasium.com/integrallis/excemel)
[![Code Climate](https://codeclimate.com/github/integrallis/excemel.png)](https://codeclimate.com/github/integrallis/excemel)
[![Coverage Status](https://coveralls.io/repos/integrallis/excemel/badge.png?branch=master)](https://coveralls.io/r/integrallis/excemel?branch=master)

Excemel is a Ruby DSL for Elliotte Rusty Harold's XOM XML library. It is based
on Jim Weirich's Builder. Excemel brings to JRuby the expressiveness and
close-to-the-language XML construction features of Builder with the correctness,
simplicity, and performance of XOM.

Excemel extends the semantics of Builder with methods to navigate the
in memory XML document with XPath and exposing some of the powerful XML
manipulation capabilities of XOM.

## Usage

See usage examples under /examples directory of this distribution

## Contact

* Author::     Brian Sam-Bodden and the Integrallis Crew
* Email<EMAIL_ADDRESS>* Home Page::  http://integrallis.com
* License::    MIT Licence (http://www.opensource.org/licenses/mit-license.html)

repository: integrallis/excemel

repo_name: integrallis/excemel


text:
# Lab05-OOP-Principles

## About This Program
Zoo

Author: Karina Chen

## Description
This program demonstrates the 4 Object-Oriented-Programming principles: Abstraction, Encapsulation, Inheritance, and Polymorphism.
There are three inheritance layers containing abstract and concrete classes. The classes contains abstract, virtual, and concrete properties and methods. The classes also inherit from the two interfaces. This program is a good example to show how 4 OOP principles work.

## Getting Started
Clone this repository to your local machine.

$ git clone [https://github.com/karina6188/Lab05-OOP-Principles.git]

To run the program from Visual Studio:
Select File -> Open -> Project/Solution

Next navigate to the location you cloned the Repository.

Double click on the Lab05-OOP-Principles directory.

Then select and open lab05-oop-principles.

## To Run This Program
Open the program using Visual Studio and click "Start" button to run this program.

## Visuals

Unified Modeling Language

This drawing illustrates the inheritance layers of each class and their properties and methods.

![Alt execution capture](/captures/UML2.JPG)

Application Execution

![Alt execution capture](/captures/app_execution2.JPG)

## Technical Documentation
Object-Oriented Programming Principles:

### Abstraction
Abstraction is used to carry information (methods, properties,...) to other classes that other classes can then redefine the information to fit their various features to make it more specific to each class.

Example:
Animal class is an abstract class that carries the IsInZoo properties to its child classes.

### Encapsulation
Encapsulation means to group related things together that contains functions and variables.

Example:
The constructor method for class Mammal.

### Inheritance
Inheritance allows you to extend the information from a parent class to a child class. Then in the child class, you can make modifications without changing the original file.

Example:
Class Salmon inherits from class Fish, so class Salmon inherits properties and methods from its parent class and also from the ancestors' classes.

### Polymorphism
Polymorphism allows you to link classes with other classes, and the classes can still functions as their original classes even when they are assigned as other classes.

Example:
Mammal tiger = new Tiger(520, 9);
tiger.Sleep();

The method Sleep() is from class Animal which is a parent class of class Mammal which is a parent class of Tiger.
Polymorphism allows you to make a new instance Tiger as a type Mammel, and allows you to call the Sleep() method from Animal class.

### Interfaces
Interfaces allows you to include behaviors from multiple sources in a class. In C#, since a class can only inherit from one class, interfaces can be used to include more functions to a class without "inheriting" from it.
There are two interfaces in this program, IFeed and IWater. IFeed is implemented to class Mammal and Fish, and IWater is implemented to class Mammal and Bird.

Example:
salmon.FeedFood();
tiger.FeedFood();
eagle.GiveWater();

These codes can be run successfully because their parent class (Fish, Bird, and Mammal) implement interfaces IFeed and IWater.

## Change Log

1.1: Set up the program and added classes into the program. - 2019 Oct 21

1.2: Add properties and methods to each class. - 2019 Oct 21

1.3: Fix bugs and override virtual properties. - 2019 Oct 21

1.4: Add unit testing to test if all the classes can run functions from their inherited classes. Pass all tests. - 2019 Oct 21

1.5: Add two interfaces to classes. - 2019 Oct 22

1.6: Add more unit testing to test interfaces. - 2019 Oct 22

1.7: Fix bugs and the program is completed. - 2019 Oct 22

gha_language: C#


text:
---
layout: post
title:  "Review of Hackreactor Fulcrum Prep"
date:   2016-09-06 00:32:00 +0700
tag: JS, programming
---

I recently did an online course called Fulcrum with Hackreactor and this is my small reflection about it.

## 1) Structure
Students were given functions to write, the original documentation, and their respective tests. This is great because it gave us a hands-on experience with documentation and test suite reading. For instance, we had to manipulate the test code to our needs to figure out what went wrong.

## 2) Native methods
Our first task was to write out all sorts of key basic functions such as Math.max, array pop join, and string slice. This exercise is great for three reasons. First, it truly felt like we were understanding programming from the ground-up. No external functions were allowed. Second, the exercise really forces you to become good/creative at lower-level functions, such as looping, setting conditions, etc. Third, we spent enough time with each function that we knew them by heart.

## 3) Underscore library
"Underscore is a JavaScript library that provides a whole mess of useful functional programming helpers without extending any built-in objects."

Next, we had to implement some of the key functions in the underscore library. The toughest part about it, I argue, are probably higher order functions. Writing them out required you to constantly keep track of what is being passed to what. This gets easier over time with practice, but the initiation process still took me by surprise.

There are also other material such as recursion, frontend, and prototypal stuff, in which I won't get into, but overall, I really felt like the course provided very solid understanding of the language and program in general for me.

extension: markdown

gha_language: HTML


text:
+++
title = "Create EKS Cluster"
chapter = false
weight = 101
+++

Before creating the EKS cluster, please make sure that you have the right role.

```sh
aws sts get-caller-identity --query Arn | grep TeamRole -q && echo "IAM role valid" || echo "IAM role NOT valid"
```

If the IAM role is not valid, **DO NOT PROCEED**. Go back and confirm the steps on this page.

Once you have ensured your IAM role is valid, proceed to define your cluster configuration.

Create a `cluster.yaml` file in the root of your Cloud9 environment. Copy and paste the yaml below:

```yaml
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
  name: gitopssdlcworkshop
  region: us-west-2
nodeGroups:
  - name: default
    instanceType: m5.large
    desiredCapacity: 2
    volumeSize: 120
    iam:
      withAddonPolicies:
        appMesh: true
        xRay: true
```

To create the EKS cluster, you will need to run the following command:

```bash
# make sure we are in the root environment folder
cd ~/environment

# Create the cluster
eksctl create cluster -f cluster.yaml
```

The creation of the cluster typically takes about 20 minutes. You can monitor the progress of your cluster by navigating to `AWS Console > Services > CloudFormation`.

Since we have some time, let's review some [Advanced Deployment Strategies](/50_workshop_5_accelerating_sdlc/15_deployment_strategies.html).


text:
CatBoost on Amazon Web Services(AWS)
====================================
We created a preconfigured Amazon Machine Image with installed CatBoost and [Epsilon](https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary.html#epsilon) data pool. It supports training with both CPU and GPU. You may exploit acceleration of one or several GPU compute units to significantly speed up the training.

To start the image on Amazon Web Services follow the next steps:

1. Switch to US West (Oregon) region -> EC2 console -> Launch Instance -> in Community AMIs, search CatBoost, select: CatBoost v0.5 CPU/GPU with Epsilon pool -> Instance Type:p2.xlarge(GPU compute) -> Instance details(as is) -> Storage: 100Gb => Review and Launch

2. ssh into the started instance, and use the following examples to start training with GPU acceleration:
- command line version: "cd ~/catboost; ./train_epsilon10K_gpu.sh"
- python version: "cd ~/catboost; python train_epsilon10K_gpu.py"
- for CPU only training check train_epsilon10K_cpu.sh and train_epsilon10K_cpu.py
- for performance run use full version of Epsilon pool and scripts train_epsilon_gpu.sh or train_epsilon1_gpu.py or CPU analogues. Please be patient, it may take a while (up to 40min) for the very first read of the pool due Amazon disk replication mechanism.

The instance contains:
- CatBoost (at /home/ubuntu/catboost/catboost)
- Epsilon pool in TSV format (/home/ubuntu/catboost/epsilon_normalized.pool) and it's short version (first 10K lines) at (/home/ubuntu/catboost/epsilon_normalized10K.pool)
- Command line and python scripts to start training on Epsilon pool using CatBoost on CPU or GPU (at /home/ubuntu/catboost)

repository: Antoshqa/catboost

repo_name: Antoshqa/catboost


text:
---
title: js-snake
type: page
---

[See on GitHub](https://github.com/jakeroggenbuck/js-snake/)

# js-snake
Snake game written in p5 JS
Requires a local node server.
install http-server by running "npm install http-server",
then while in the js-snake folder run "http-server",
finally connect to "http://localhost:8080/" and open js-snake.html.

gha_language: CSS


text:
![Digital Accessibility banner](images/accessibility.png)
> Image by [Jen Looper](https://twitter.com/jenlooper)

# Digital Accessibility Content

Resources of interest to students and faculty all about Digital Accessibility, including all the ways that we make our apps usable for everyone.

## Talks
[Testing Web Accessibility by Adrián Bolonio](https://techa11y.dev/main-track/testing-web-accessibility/)
>How to find accessibility vulnerabilities in your website ~ Tech A11y Summit 2021 ([Slide Deck](https://speakerdeck.com/bolonio/testing-web-accessibility))

[Inclusive Design, more than you hear by Marie van Driessche](https://techa11y.dev/main-track/inclusive-design-more-than-you-hear/)
>Marie van Driessche gives inclusive design tips on improving the usability and readability of your website. She will sign about how sign language is an intrinsically different way of communicating and how to make your website accessible for Deaf people, but actually for everyone. ~ Tech A11y Summit 2021

[FronteND and BackeND (Accommodate NeuroDiversity in your products) by Anna Korinna Németh-Szabó](https://techa11y.dev/main-track/frontend-and-backend-accommodate-neurodiversity-in-your-products/)
>In this session, Anna Korinna Németh-Szabó brings you challenges that neurodiverse users face every day, pinpoint struggles they encounter when using less-than-inclusive products, and offer best practices about how you can make your products accessible, inclusive, and user-friendly for a neurodiverse audience, too. ~ Tech A11y Summit 2021

## Code Samples

## Tools
[Accessibility Insights by Microsoft](https://accessibilityinsights.io/)
>Test accessibility of webpages, web applications, Android applications and Windows applications

[WebAIM: Contrast Checker](https://webaim.org/resources/contrastchecker/)
>Check if the contrast ratio of your design's foreground and background colors adhere to Web Content Accessibility Guidelines (WCAG)

[Accessible Color Palette Builder](https://toolness.github.io/accessible-color-matrix/)
>Generate a matrix that shows accessible color pairings from your color scheme

[alex](https://alexjs.com/)
>Catch insensitive, inconsiderate writing

## Courseware
[Accessibility Fundamentals Learning Path on Microsoft Learn](https://docs.microsoft.com/learn/paths/accessibility-fundamentals/)
>Take lessons on Microsoft Learn about digital accessibility

## Blogs

## Initiatives
[The XRAccessibility Project](https://xraccessibility.github.io/)
>The XRAccessibility Project is an initiative driven by the XR Association and XR Access to provide a central place for developers to find solutions for creating accessible code across various XR platforms.

## Events
[Microsoft Ability Summit 2022](https://abilitysummit2022.eventcore.com/)
>Microsoft Ability Summit is a free, community event that brings together people with disabilities, allies, and industry professionals to Imagine, Build, and Include the future of disability inclusion and accessibility.

repository: Rajdeep-Das/computerscience

repo_name: Rajdeep-Das/computerscience


text:
# ACME4J Certificate Generator

**acme4j-certificate-generator** is a tool with is a single main class written in Kotlin, that helps connecting to an ACME server, and performing all necessary steps to manage free certificates from Let's Encrypt :
* Create a private key for your Let's Encrypt account
* Create a Let's Encrypt account using the private key generated in the previous phase
* Create a certificate order and send it to Acme4J, to obtain a certificate

It is based on the [ACME 4J](https://github.com/shred/acme4j) librairy.

Acme4j is a Java toolkit that enables you to automate the creation of free TLS / SSL certificates.
Acme4J is obtaining the TLS / SSL certificates by communicating with the Let's Encrypt certificate authority (CA).
Automating certificate generation is a big advantage over updating certificates manually.
When automated you save time, and you can changes certificates more often, reducing the risk of your certificate getting compromised.

**acme4j-certificate-generator** Requires JRE 8 (update 101) or higher

## Usage

## Note from author
I followed [Jenkov Acme4J Tutorial](http://tutorials.jenkov.com/acme4j/index.html) to code this tool.


text:
# JIRA Smart Commit

![tests](https://github.com/jessedobbelaere/jira-smart-commit/workflows/run-tests/badge.svg)
[![GitHub release](https://img.shields.io/github/release/jessedobbelaere/jira-smart-commit.svg)](https://github.com/jessedobbelaere/jira-smart-commit/releases/latest)
[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=jessedobbelaere/fork-cms-webpack-boilerplate)](https://dependabot.com)
[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)
[![Downloads](https://img.shields.io/npm/dt/jira-smart-commit.svg)](https://www.npmjs.com/package/jira-smart-commit)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat)](http://makeapullrequest.com)

A Node.js git hook script to prefix commits automatically with the JIRA ticket, based on a branch name.

## Usage

### Installation

1. Install [Husky](https://www.npmjs.com/package/husky) in your project to configure Git hooks easily.

```bash
npm install --save-dev husky
```

2. Install this package in your project:

```bash
npm install --save-dev jira-smart-commit
```

3. Configure scripts in `package.json`. The script expects his first argument to be the JIRA tag of the project.

```json
    "husky": {
        "hooks": {
            "commit-msg": "jira-smart-commit YOUR_JIRA_ISSUE_KEY",
            "pre-commit": "lint-staged"
        }
    },
```

Alternatively: use a regex to detect the Jira `ISSUE_KEY` in your branch.

- `TAG_MATCHER` - regular expression
- `TAG_MATCH_INDEX` - match index

Example: if your branch names looke like `feature/JRA-1234/some-description` template

```
"commit-msg": "TAG_MATCHER=\"^[^/]+/(JRA-[0-9]+)\" TAG_MATCH_INDEX=1 jira-smart-commit"
```

4.  If the branch was prefixed with a JIRA tag, your commit message will get prefixed with
   the same tag.

```
Branch: JRA-411-husky-git-hooks
Commit message: "Add git hooks to project" → "JRA-411 Add git hooks to project"
```

repository: jessedobbelaere/jira-smart-commit

repo_name: jessedobbelaere/jira-smart-commit


text:
---
layout: page
title: About
permalink: /about/
---

Hello! I'm Baruch Rutman, also known as my internet nickname Peterooch.
I'm a Software Engineering student at Sami Shamoon College of Engineering in the lovely city of Be'er Sheva in Israel.
Previously I was hobbyist programmer that still likes to program things just to solve problems I encounter in my daily life.

Programming since 2009 starting with toying with JavaScript.
Open source contributor since 2013, mainly contributing to ReactOS.
Also contributed in a smaller scale to Microsoft Winfile, Wine, UniExtract2.
Started studying Software Engineering in the spring of 2019.
Currently in a break between second and third year.

I know to program things in the following languages and technologies (in order of experience/comfort):
- C / C++ with additional experience in Win32 API
- C# and MVC.NET Core (with EF Core)
- Python with pandas, sklearn and other data oriented libraries
- JavaScript (and some little amounts of JQuery)
- Java

Currently looking for a student position in the field, do contact me if you think I'll fit your team/company.

Other tidbits:
I know to design basic things in HTML, CSS and Bootstrap.
I use Visual Studio Code for everything because why not. (I'm looking at you JetBrains)

Current goals programming wise are to make RTL mirroring to work in ReactOS.

Learned while working on BiDi and Mirroring support how Windows does some of those things even though
 I'm using Wine as reference of functioning implementation.


text:
# ElasticSearch index dumper

Easily dump/restore complete or partial indices to/from compressed JSON files.

Each index entry will be represented by a line:
```
{"id":"<id>","type":"<type>","source":{<source>}}
```

You can use `query` argument to specify ElasticSearch query in JSON format to filter out records you want to backup.

Example usage arguments:
```
-hosts=http://host07:9200,http://host06:9200                          # ES hosts to connect to
-index=my-index                                                       # index to dump
-out=my-index-2017                                                    # file prefix to use
-split=100000                                                         # how many records per file (omit for single file, see note below)
-page=5000                                                            # how many results per scroll to process
-query="{\"range\":{\"dateCrawled\":{\"gte\":\"2017-01-01 0:0:0\"}}}" # ES query to use for partial dumps
```
Note, that records are kept in memory before they are written to file in compressed form, so it is feasible to specify decent `split` argument to avoid memory exhaustion for really big indices.

Will produce files like:
```
my-index-2017.00000000.json.gz
my-index-2017.00000001.json.gz
my-index-2017.00000002.json.gz
...
```

# Index restorer

Example usage arguments:
```
-hosts=http://host07:9200,http://host06:9200                          # ES hosts to connect to
-index=my-index                                                       # index to restore
-files=index.*.json.gz                                                # glob file mask
```

repository: BrightLocal/ES-Backup

gha_language: Go

repo_name: BrightLocal/ES-Backup


text:
Bronze/MVP:
* work through tutorials to deepen knowledge of accessibility.
* build simple static site using react and gatsby that is fully accessible (based on WCAG guidelines and testing) with the following features: home, resources, about.
* test accessibility of site

Silver:
* full CRUD functionality
* add user authentication
* test accessibility of site with Selenium WebDriver and axe

Gold/Stretch Goals:
* connect to Accessibility API
* user testing
* build API of resources


text:
---
layout: post
title: "Neural Network Based Nonlinear Weighted Finite Automata"
date: 2017-09-13 15:26:50
categories: arXiv_CL
tags: arXiv_CL
author: Tianyu Li, Guillaume Rabusseau, Doina Precup
mathjax: true
---

* content
{:toc}

##### Abstract
Weighted finite automata (WFA) can expressively model functions defined over strings. However, a WFA is inherently a linear model. In this paper, we propose a neural network based nonlinear WFA model along with a learning algorithm. Our learning algorithm performs a nonlinear decomposition of the so-called Hankel matrix (using an encode decoder neural network) from which the transition operators of the model are recovered. We assessed the performance of the proposed model in a simulation study.

##### Abstract (translated by Google)
加权有限自动机（WFA）可以表达性地模拟在字符串上定义的函数。然而，WFA本质上是一个线性模型。在本文中，我们提出了一个基于神经网络的非线性WFA模型和一个学习算法。我们的学习算法执行所谓的汉克尔矩阵（使用编码解码器神经网络）的非线性分解，从中恢复模型的转换算子。我们在模拟研究中评估了所提出的模型的性能。

##### URL
[https://arxiv.org/abs/1709.04380](https://arxiv.org/abs/1709.04380)

##### PDF
[https://arxiv.org/pdf/1709.04380](https://arxiv.org/pdf/1709.04380)


text:
Pthread
=======

## Introduction

Use the default CMake macros
[here](https://cmake.org/cmake/help/v3.10/module/FindThreads.html).

## Usage

Simply add to you CMakeLists.txt:

    find_package(Threads REQUIRED)

    target_link_library(my_lib Threads::Threads)

gha_language: CMake


text:
# Introduction

This book contains learning ressources and tutorials about many of the technologies
we used for our participation(s) in the Eurobot contests.

The [Eurobot contest](http://www.eurobot.org/) is an international amateur robotics contest.
The objective is to build an autonomous robot that needs to accomplish a given set of tasks, earning you points.

Through this book, we hope to be able to transfer the knowledge and experience we have acquired during our participation to
the team that will participate next year. Our hope is that over the years, this ressource will grow with each participation
to become a huge source of information for anyone that wants to participate in the contest.

# 2018

![Participants of 2018](img/2018.jpg)

# 2019

![Participants of 2019](img/2019.jpg)

repository: nofazo/Tutorials

repo_name: nofazo/Tutorials


text:
RXTX PI
=========

RXTX PI is an code example, how you can setup and code with RXTX on your Raspberry PI.

RXTX is an Open Source implementation of Java Communications API.

License
-------
RXTX PI is being released under the Apache License, Version 2.0. You can download the complete license text at
http://www.apache.org/licenses/LICENSE-2.0.html

repository: grafjo/rxtxpi

repo_name: grafjo/rxtxpi


text:
Retrieves a FireFlow change request by its ID.

## Script Data
---

| **Name** | **Description** |
| --- | --- |
| Script Type | python |
| Tags | Algosec |

## Dependencies
---
This script uses the following commands and scripts.
* algosec-get-ticket

## Inputs
---

| **Argument Name** | **Description** |
| --- | --- |
| ticketId | The ID of the requested change request. |

## Outputs
---
There are no outputs for this script.

repository: demisto/content

gha_language: Python

repo_name: demisto/content


text:
---
layout: post
title:  "Tara Devi"
date:   2018-06-03 02:47:00
author: Ajar Vashisth
categories:
  - "India"
  - "Himachal Pradesh"
  - "Shimla"
tags:
  - travel
  - hiking
  - himachal
  - Western Himalayas
  - Indian Mountains
excerpt: Taradevi trail a jewel in the natural beauty of Shimla and adjoining areas
hike_info:
  id: shimla_tara_devi_01
  title: Tara Devi
  variant: Tara Devi Bus Stop - Tara Devi Temple - Shiv Temple - Tara Devi Bus stop
  distance:
    value: 4
    units: miles
  elevation:
    gain:
      value: 2000
    units: feet
  duration:
    text: 2 hrs to 5 hrs
  map:
    waypoints:
      - label:  Trailhead
        lat : 31.075646
        lng : 77.139461
      - label: Tara Devi Temple
        lat: 31.054316
        lng: 77.142353
      - label: Old Shiv Temple
        lat: 31.057521
        lng: 77.141314

cover:  "/assets/taradevi/img/td-01.jpg"
custom_js:
  - hike_view
---
{% include hike-vitals-widget.html  %}

Tara Devi Temple is located on a beautiful mountian top near the iconic city of Shimla. According to folklore the Temple was constructed by Maharaja of Junga State after he had visions of Godess in his greams. The temple is located on an isolated mountain top which offers sweeping 360 degree views of Shimla and adjoining regions.

Taradevi temple is very popular amongst Shimla locals and up until early 2000's people visited the temple on foot walking through the scenic trail through the dense Tara Devi forest. A motorable road which goes all the way to the Temple top now carries majority of the Temple visitor traffic. The trail traffic has been reduced to `5 %` of what it used to be.  The trail is still in a very good shape and the lower people volume is a boon in a way for preventing the environment pollution due to plastic.

### Want to do this hike ?
---

#### Preperation
---
**Difficulty**
* This is a moderately easy hike and anyone in good walking condition can do it.

**Best Season**
* This trail is open all year
* The trail can get slippery after a good rain. If you are super cautious avoid it on a rainy day.

**Which Day?**
* Any non rainy day is a good day for this hike.
* Sunday's are busiest days on this trail.
* If you reach the temple by afternoon on a Sunday, you can enjoy a free lunch at the Temple `bhandara`

**What to take along?**
* Hiking / Sports shoes with Good grip recommended.
- The trail can accumulate piles of leaves which are sometimes slipery to walk on.
* Take a water bottle with you as there is no potable water on the way up to the temple.
* Please don't litter the trail with plastic from packaged snacks.

#### On the Day of Hike
---
`Approximate Time 3 hours 30 minutes` Round trip

`30 min`**Reaching the trail Head from Shimla**

* Board a local bus from Shimla bus stand for Tara Devi bus stop.
* You may have to wait for couple of minutes for the bus.
* You may or may not get a seat as the bus gets crowded.

`1 hr`**Getting on the trail**
* After getting off the Bus, ask a local for the way to Tara Devi Temple.
* Walk for around 1000 ft  [watch5min] up the trail and you will meet a fork. Take the right fork and continue.
* If you can maintain a good pace you should reach the Temple in 45 minutes. If you are very slow you will reach the temple in less than 2 hours

`20 min`**Return via Shiv Temple**
* From the temple retreat about 100 feet and then find a trail down to Shiv Temple. The trail is paved in concrete and well marked.
* You should reach the Shiv Temple in around 20 minutes

`1 hr`**Onward from Shiv Temple**
* Take a rest for some minutes at Shiv temple. Fill your water supplies with the natural spring water.
* The trail to the right continues back to meet the earlier trail we took up to the temple.
* Continue down to the the bus stop. It will take around 45 minutes to 1 hr 15 minutes for you to reach back at the trail head from here.

`30 min`**Back to Shimla**
* Take the bus back to Shimla.
* If you are in fun mood and lucky , you might even board the train from Tara Devi back to Shimla.__Check Train Timings for this__

_Happy Hiking_

repository: ajarv/wiki

repo_name: ajarv/wiki


text:
---
layout: post
title:  "25 Gbit/s HTTP and HTTPS download speeds"
date:   2022-05-14 16:18:00 +02:00
categories: Artikel
tweet_url: "https://twitter.com/zekjur/status/1525482567096537090"
tags:
- fiber
---

Now that I [recently upgraded my internet connection to 25
Gbit/s](/posts/2022-04-23-fiber7-25gbit-upgrade/), I was curious how hard or
easy it is to download files via HTTP and HTTPS over a 25 Gbit/s link. I don’t
have another 25 Gbit/s connected machine other than my router, so I decided to
build a little lab for tests like these 🧑🔬

## Hardware and Software setup

I found a Mellanox ConnectX-4 Lx for the comparatively low price of 204 CHF on
digitec:

{{}}

To connect it to my router, I ordered a MikroTik XS+DA0003 SFP28/SFP+ Direct
Attach Cable (DAC) with it. I installed the network card into my old workstation
(on the right) and connected it with the 25 Gbit/s DAC to router7 (on the left):

{{}}

### 25 Gbit/s router (left)

| Component    | Model                                                                                |
|--------------|-----------------------------------------------------------------------------------------------------------------|
| Mainboard    | ASRock B550 Taichi                                                                                |
| CPU          | AMD Ryzen 5 5600X 6-Core Processor                                                                              |
| Network card | [Intel XXV710](https://www.fs.com/de/products/75603.html)                                                       |
| Linux        | Linux 5.17.4 ([router7](https://router7.org))
curl 7.83.0 from debian bookworm
Go `net/http` from Go 1.18 |

router7 comes with [TCP
BBR](https://en.wikipedia.org/wiki/TCP_congestion_control#TCP_BBR) enabled by
default.

### Old workstation (right)

| Component    | Model                                              |
|--------------|----------------------------------------------------|
| Mainboard    | ASUS PRIME Z370-A                                  |
| CPU          | Intel i9-9900K CPU @ 3.60GHz                       |
| Network card | Mellanox ConnectX-4                                |
| Linux        | 5.17.5 (Arch Linux)
nginx 1.21.6
caddy 2.4.3 |

## Test preparation

Before taking any measurements, I do one full download so that the file contents
are entirely in the Linux page cache, and the measurements therefore no longer
contain the speed of the disk.

`big.img` in the tests below refers to the 35 GB test file I’m downloading,
which consists of distri-disk.img repeated 5 times.

## T1: HTTP download speed (unencrypted) {#http}

### T1.1: Single TCP connection {#http1}

The simplest test is using just a single TCP connection, for example:

```bash
curl -v -o /dev/null http://oldmidna:8080/distri/tmp/big.img
./httpget25 http://oldmidna:8080/distri/tmp/big.img
```

| Client   | Server    | Gbit/s                     |
|----------|-----------|----------------------------|
| **curl** | **nginx** | **{{< bar speed=23.4 >}}** |
| curl     | caddy     | {{< bar speed=23.4 >}}     |
| Go       | nginx     | {{< bar speed=20 >}}       |
| Go       | caddy     | {{< bar speed=20.2 >}}     |

curl can saturate a 25 Gbit/s link without any trouble.

The Go `net/http` package is slower and comes in at 20 Gbit/s.

### T1.2: Multiple TCP connections {#http4}

Running 4 of these downloads concurrently is a reliable and easy way to saturate
a 25 Gbit/s link:

```bash
for i in $(seq 0 4)
do
  curl -v -o /dev/null http://oldmidna:8080/distri/tmp/big.img &
done
```

| Client | Server | Gbit/s                 |
|--------|--------|------------------------|
| curl   | nginx  | {{< bar speed=23.4 >}} |
| curl   | caddy  | {{< bar speed=23.4 >}} |
| Go     | nginx  | {{< bar speed=23.4 >}} |
| Go     | caddy  | {{< bar speed=23.4 >}} |

## T2: HTTPS download speed (encrypted) {#https}

At link speeds this high, enabling TLS slashes bandwidth in half or worse.

Using 4 TCP connections allows saturating a 25 Gbit/s link.

Caddy uses more CPU to serve files compared to nginx.

### T2.1: Single TCP connection {#https1}

This test works the same as T1.1, but with a HTTPS URL:

```bash
curl -v -o /dev/null --insecure https://oldmidna:8443/distri/tmp/big.img
./httpget25 https://oldmidna:8443/distri/tmp/big.img
```

| Client | Server    | Gbit/s                   |
|--------|-----------|--------------------------|
| curl   | nginx     | {{< bar speed=8 >}}      |
| curl   | caddy     | {{< bar speed=7.5 >}}    |
| **Go** | **nginx** | **{{< bar speed=12 >}}** |
| Go     | caddy     | {{< bar speed=7.2 >}}    |

### T2.2: Multiple TCP connections {#https4}

This test works the same as T1.2, but with a HTTPS URL:

```bash
for i in $(seq 0 4)
do
  curl -v -o /dev/null --insecure https://oldmidna:8443/distri/tmp/big.img &
done
```

Curiously, the Go `net/http` client downloading from caddy cannot saturate a 25
Gbit/s link.

| Client | Server | Gbit/s                 |
|--------|--------|------------------------|
| curl   | nginx  | {{< bar speed=23.4 >}} |
| curl   | caddy  | {{< bar speed=23.4 >}} |
| Go     | nginx  | {{< bar speed=23.4 >}} |
| Go     | caddy  | {{< bar speed=21.6 >}} |

## T3: HTTPS with Kernel TLS (KTLS) {#httpsktls}

Linux 4.13 got support for Kernel TLS back in 2017.

nginx 1.21.4 introduced support for Kernel TLS, and they have a [blog post on
how to configure
it](https://www.nginx.com/blog/improving-nginx-performance-with-kernel-tls/).

In terms of download speeds, there is no difference with or without KTLS. But,
enabling KTLS noticeably reduces CPU usage, from ≈10% to a steady 2%.

For even newer network cards such as the Mellanox ConnectX-6, the kernel can
even offload TLS onto the network card!

### T3.1: Single TCP connection {#httpsktls1}

| Client | Server    | Gbit/s                   |
|--------|-----------|--------------------------|
| curl   | nginx     | {{< bar speed=8 >}}      |
| **Go** | **nginx** | **{{< bar speed=12 >}}** |

### T3.2: Multiple TCP connections {#httpsktls4}

| Client | Server | Gbit/s                 |
|--------|--------|------------------------|
| curl   | nginx  | {{< bar speed=23.4 >}} |
| Go     | nginx  | {{< bar speed=23.4 >}} |

## Conclusions

When downloading from nginx with 1 TCP connection, with TLS encryption enabled
(HTTPS), the Go `net/http` client is faster than curl!

Caddy is slightly slower than nginx, which manifests itself in slower speeds
with curl and even slower speeds with Go’s `net/http`.

To max out 25 Gbit/s, even when using TLS encryption, just use 3 or more
connections in parallel. This helps with HTTP and HTTPS, with any combination of
client and server.

## Appendix

Go net/http test program httpget25.go

```go
package main

import (
	"crypto/tls"
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
)

func httpget25() error {
	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

	for _, arg := range flag.Args() {
		resp, err := http.Get(arg)
		if err != nil {
			return err
		}
		if resp.StatusCode != http.StatusOK {
			return fmt.Errorf("unexpected HTTP status code: want %v, got %v", http.StatusOK, resp.Status)
		}
		io.Copy(ioutil.Discard, resp.Body)
	}
	return nil
}

func main() {
	flag.Parse()
	if err := httpget25(); err != nil {
		log.Fatal(err)
	}
}
```

Caddy config file Caddyfile

```
{
  local_certs
  http_port 8080
  https_port 8443
}

http://oldmidna:8080 {
  file_server browse
}

https://oldmidna:8443 {
  file_server browse
}
```

nginx installation instructions

```
mkdir -p ~/lab25
cd ~/lab25

wget https://nginx.org/download/nginx-1.21.6.tar.gz
tar tf nginx-1.21.6.tar.gz

wget https://www.openssl.org/source/openssl-3.0.3.tar.gz
tar xf openssl-3.0.3.tar.gz

cd nginx-1.21.6
./configure --with-http_ssl_module --with-http_v2_module --with-openssl=$HOME/lab25/openssl-3.0.3 --with-openssl-opt=enable-ktls
make -j8
cd objs
./nginx -c nginx.conf -p $HOME/lab25
```

nginx config file nginx.conf

```
worker_processes  auto;

pid        logs/nginx.pid;

daemon off;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    access_log /home/michael/lab25/logs/access.log  combined;

    sendfile        on;
    sendfile_max_chunk 2m;

    keepalive_timeout  65;

    server {
        listen       8080;
        listen [::]:8080;
        server_name  localhost;

        root /srv/repo.distr1.org/;

        location / {
            index index.html index.htm;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root /usr/share/nginx/html;
        }

        location /distri {
            autoindex on;
        }
    }

    server {
        listen 8443 ssl;
        listen [::]:8443 ssl;
        server_name localhost;

        ssl_certificate nginx-ecc-p256.pem;
        ssl_certificate_key nginx-ecc-p256.key;

        #ssl_conf_command Options KTLS;

        ssl_buffer_size 32768;
        ssl_protocols TLSv1.3;

        root /srv/repo.distr1.org/;

        location / {
            index index.html index.htm;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root /usr/share/nginx/html;
        }

        location /distri {
            autoindex on;
        }
    }
}
```

repository: stapelberg/hugo

repo_name: stapelberg/hugo


text:
# f1telemetry

C++ Telemetry tools for the Formula 1 game F12018 by CodeMasters

## Background

There was a time when I was pretty good at C++. But that was a long time ago.

I wanted to work on a simple project that would let me re-learn some of those long forgotten C++ concepts, so I decided to combine some of my passions (Formula 1, and F1 gaming) to help me along this journey.

And man, what a journey. I've been away from C++ for far too long...

I'm sure I did things wrong, and I encourage anybody who knows this world better than me to provide helpful advice.

## F12018 by Codemasters

So F12018 is a pretty awesome game. Admittedly it is not the best SIM out there... if you're looking for real authenticity I'm confident you'll do better looking into R-Factor or some of the other real sims. But for me F12018 is the right amount of fun vs real physics.

From a technical perspective the game is interesting because it broadcasts a motherload of data about your races and laps via UDP. CodeMasters was kind enough to provide the spec for the format here:

https://forums.codemasters.com/discussion/136948/f1-2018-udp-specification

## What is f1telemetry?

This repo has two programs to help you collect and extract the f1 telemetry data that is broadcast by the F12018 game.

### Building

I addition to learning C++, I wanted to get comfortable with some of the latest/greatest in the world of toolchains. I discovered [bazel](https://bazel.build/) and decided it would probably make my life a bit easier and I could learn something new as well. So I used bazel

To build the two apps, you run the following bazel commands:

```
% cd f1telemetry
% bazel build //capture
% bazel build //extract
```

### Setting up the F1 Game

In order to capture data, you'll need to set up your F12018 game to broadcast. I have a PS4, so hopefully configuration on other platforms is similar:

* Run the F12018 Game
* From the main menu, open "Game Options"
* Open Settings -> Telemetry Settings
* Turn UDP Telemetry On

Most of the rest of the configuration settings can remain the same, unless there is something different about your home network.

If you want more detailed telemetry, you can up the UDP send rate. Be warned, the higher the send rate, the larger your capture files will be. For example, I tried 60Hz, and one single lap of a track burned a 30MB hole in my hard drive.

After configuring the game properly, it will always broadcast UDP race data on your local network.

### Capturing Data

To capture data, run a command like this:

```
% ./bazel-bin/capture/capture -p 20777 -o my_capture_file
```

Captured data is in the raw form spat out by the F1 game: packed UDP bytes. The capture server doesn't do anything really smart, it just pipes the data to a file.

### Extracting Data

The extract command converts the captured files to CSV so you can analyze and process them.

To extract telemetry data, run the following command:

```
% ./bazel-bin/capture/capture -i my_capture_file -o my_telemetry_file.csv
```

## Known Issues

* The extract program hardcodes 20 drivers. Bad. Bad. I didn't spend the time to figure out how to do this properly, and the extract code doesn't work with time trials currently, only races with 20 drivers. If anybody wants to take a look and help me figure it out, I'd be very appreciative!

## Feedback

Let me know if you gave the code a whirl and how it worked out. Feel free to give me feedback, C++ tips, general life advice, or whatever.


text:
# Building middleware

## Write middleware that sets the current culture based on a query string value
1. Start with the application from lab 6 (*Lab6D* in the Code folder).
1. Open `Startup.cs`
1. Create an inline middleware that runs **before** the UseMvc middleware:

    ``` CSharp
    app.Use((context, next) =>
    {
        var cultureQuery = context.Request.Query["culture"];
        if (!string.IsNullOrWhiteSpace(cultureQuery))
        {
            var culture = new CultureInfo(cultureQuery);

            CultureInfo.CurrentCulture = culture;
            CultureInfo.CurrentUICulture = culture;
        }

        // Call the next delegate/middleware in the pipeline
        return next();
    });
    ```
1. Set a break point on a controller action (`ProductsController.Get`, for
example).
1. Launch the app and navigate to the URL with a breakpoint set, using a
culture query string as part of the URL, for example:
http://localhost:8081/api/Products?culture=fr-FR
1. When the debugger breaks, run
`System.Globalization.CultureInfo.CurrentCulture` in the immediate window and
notice that the current culture has been updated.

## Move the middleware to its own type
1. Create a new class in the application's middleware folder called
`RequestCultureMiddleware.cs` (create the middleware folder if you don't have
it from previous labs).
1. Add a constructor that takes a parameter `RequestDelegate next` and
assigns it to a private field `private readonly RequestDelegate _next`
1. Add a method `public Task Invoke(HttpContext context)`
1. Copy the code from the inline middleware delegate in the application's
`Startup.cs` file to the `Invoke` method you just created and fix the
`next` method name
1. Your middleware class should now look something like this:

    ```CSharp
    public class RequestCultureMiddleware
    {
        private readonly RequestDelegate _next;

        public RequestCultureMiddleware(RequestDelegate next)
        {
            _next = next;
        }

        public Task Invoke(HttpContext context)
        {
            var cultureQuery = context.Request.Query["culture"];
            if (!string.IsNullOrWhiteSpace(cultureQuery))
            {
                var culture = new CultureInfo(cultureQuery);

                CultureInfo.CurrentCulture = culture;
                CultureInfo.CurrentUICulture = culture;
            }

            return _next(context);
        }
    }
    ```
1. Update the `Configure` method in *Startup.cs* to use this middleware
instead of the inline middleware (`app.Use`) we setup previously.
    ```CSharp
    app.UseMiddleware<RequestCultureMiddleware>();
    ```

1. Most middleware provide an extension method to directly add themselves
to an `IApplicationBuilder`, though, without have to call `UseMiddleware`.
At the bottom of the *RequestCultureMiddleware.cs* file, add a class that
exposes the middleware via an extension method like this.

    ```CSharp
        public static class RequestCultureMiddlewareExtensions
        {
            public static IApplicationBuilder UseRequestCulture(this IApplicationBuilder builder)
            {
                return builder.UseMiddleware<RequestCultureMiddleware>();
            }
        }
    ```

1. Back in the application's `Startup.cs` file, delete the `UseMiddleware`
1. Add your new middleware class to the HTTP pipeline:

    ```CSharp
    app.UseRequestCulture();
    ```

1. Run the application again and see that the middleware is now running as a
class

## Adding options to middleware
1. Create a class called `RequestCultureOptions.cs` in the *Middleware*
folder with a
`CultureInfo` property called DefaultCulture.

    ```C#
    public class RequestCultureOptions
    {
        public CultureInfo DefaultCulture { get; set; }
    }
    ```
1. Add an overload to `UseRequestCulture` that takes those options and passes
them into the `UseMiddleware<RequestCultureMiddleware>` call.

    ```C#
    public static IApplicationBuilder UseRequestCulture(this IApplicationBuilder builder)
    {
        return builder.UseRequestCulture(new RequestCultureOptions());
    }

    public static IApplicationBuilder UseRequestCulture(this IApplicationBuilder builder, RequestCultureOptions options)
    {
        return builder.UseMiddleware<RequestCultureMiddleware>(options);
    }
    ```
1. Change the `RequestCultureMiddleware` constructor to take the
`RequestCultureOptions`.

    ```C#
    public class RequestCultureMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly RequestCultureOptions _options;

        public RequestCultureMiddleware(RequestDelegate next, RequestCultureOptions options)
        {
            _next = next;
            _options = options;
        }
        ...
    }
    ```

1. Change the `Invoke` method of the middleware to use the DefaultCulture
from options if none specified on the query string

    ```C#
    public Task Invoke(HttpContext httpContext)
    {
        var requestCulture = _options?.DefaultCulture;

        var cultureQuery = httpContext.Request.Query["culture"];
        if (!string.IsNullOrWhiteSpace(cultureQuery))
        {
            requestCulture = new CultureInfo(cultureQuery);
        }

        if (requestCulture != null)
        {
            CultureInfo.CurrentCulture = requestCulture;
            CultureInfo.CurrentUICulture = requestCulture;
        }

        return _next(httpContext);
    }
    ```
1. Set the fallback culture in `Startup.cs` `Configure` method to some
default value:

    ```C#
    app.UseRequestCulture(new RequestCultureOptions
    {
        DefaultCulture = new CultureInfo(Configuration["DefaultCulture"] ?? "en-GB")
    });
    ```
1. Add a 'DefaultCulture' setting to *appsettings.json*
    ```json
    "DefaultCulture": "en-AU"
    ```
1. Start debugging the application again and see the default culture when no
query string is specified matches the one configured.

## Flowing options from dependency injection system to middleware

1. Change the `RequestCultureMiddleware` constructor to take
`IOptions<RequestCultureOptions>` instead of `RequestCultureOptions`:

    ```C#
    public RequestCultureMiddleware(RequestDelegate next, IOptions<RequestCultureOptions> options)
    {
        _next = next;
        _options = options.Value;
    }
    ```

1. Change the `UseRequestCulture` extension methods to both call
`UseMiddleware<RequestCultureMiddleware>`. The overload taking
`RequestCultureOptions` should wrap it in an `IOptions<RequestCultureOptions>`
by calling `Options.Create(options)` and the overload taking no parameters no
longer needs to create a `RequestCultureOptions` to pass to `UseMiddleware`.

    ```C#
    public static class RequestCultureMiddlewareExtensions
    {
        public static IApplicationBuilder UseRequestCulture(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<RequestCultureMiddleware>();
        }

        public static IApplicationBuilder UseRequestCulture(this IApplicationBuilder builder, RequestCultureOptions options)
        {
            return builder.UseMiddleware<RequestCultureMiddleware>(Options.Create(options));
        }
    }
    ```
1. In `Startup.cs` change the `UseRequestCulture` middleware to not take any
arguments:

    ```C#
    app.UseRequestCulture();
    ```

1. In `Startup.cs` update `ConfigureServices` to configures the culture using
the `services.Configure<RequestCultureOptions>` method:

    ```C#
    services.Configure<RequestCultureOptions>(options =>
    {
        options.DefaultCulture = new CultureInfo(Configuration["DefaultCulture"] ?? "en-GB");
    });
    ```

1. Launch the application and see that options are now being configured from
the dependency injection system.

repository: mjrousos/aspnetcore-workshop

path: /Labs/7. Building Middleware.md

filename: 7. Building Middleware.md

repo_name: mjrousos/aspnetcore-workshop


text:
## Comments

A comment starts with a hash character (`#`) that is not part of a string literal, and ends at the end of the physical line. That means a comment can appear on its own or at the end of a statement. In-line comments are not supported.

This example shows a mimicked multi-line comment that consists of three `#` that are joined together:

```text
###
# This task shows the usage of comments in LoTLan
###
Task transportPalletTask
    # Comment inside a task
    Transport
    From        loadGoodsPallet  # A pallet
    To          unloadGoodsPallet
    TriggeredBy buttonPallet == True  # More comments
    OnDone      refill
    Repeat      5  # Repeat it 5 times!
End
```


text:
## hfcs-fffit/runs

The directory naming scheme is ``[molname]-[itertype]-iter[iternum]`` where ``molname`` is ``r32`` or ``r125`` and ``itertype`` is either ``density`` or ``vle``.

Each directory contains the files necessary to run the molecular simulations associated with the given molecule/iteration. The ``init.py`` defines the ``signac`` workspace and the ``project.py`` defines the flow operations (i.e., performs the system setup, creates the molecular simulation inputs, performs the simulations, and performs any analysis).

repository: helpscott/hfcs-fffit

repo_name: helpscott/hfcs-fffit


text:
# Fuse Archetype

This is a simple archetype that generates the skeleton for a JBoss Fuse project.

## How To Install

Just clone this repo and do a `mvn install` (at least until I upload it to Maven Central).

## How To Use

When creating a new project, use the following properties to specify this archetype:

`-DarchetypeArtifactId=fuse-archetype -DarchetypeGroupId=tools.devnull`

Bellow is a complete example:

~~~
mvn archetype:generate -B -DarchetypeArtifactId=fuse-archetype -DarchetypeGroupId=tools.devnull \
    -DgroupId=your.group.id \
    -DartifactId=your.artifact.id \
    -Dversion=your.version
~~~

## Features

### OSGi Development

In order to export packages from bundles, you just need to define the property `osgi.export.packages`
and the profile for defining them in the Manifest will be activated.

### Feature Project

There is a separated project with an empty `features.xml` for defining your features. The reason is
to not make your bundles aware of the existence of others. By having a specific feature module you
can centralize all the awareness into one single project.

### JBoss Fuse Repositories

The parent already provides the JBoss Fuse repositories (needed as of JBoss Fuse 6.3). The recomendation
is to not depend on specific repositories for your project. They should be available to you either
by having a mirror like Nexus or Artifactory or by having the repositories mapped in your Maven
Settings File. Since the goal of this archetype is to provide a "batteries included" structure, the
repositories are defined in the parent pom.

### Plugin Versions

If you don't provide versions for some plugins like `maven-compiler-plugin`, Maven will fetch the
latest available. This parent pom defines versions for almost every `maven-*-plugin` you need to
start developing your bundles.

### Test Dependencies

Since our codes should be testes, the parent already contains dependencies for nice test frameworks.

repository: ataxexe/fuse-archetype

repo_name: ataxexe/fuse-archetype


text:
# node-hardverapro

[![Latest version on NPM](https://img.shields.io/npm/v/hardverapro)](https://www.npmjs.com/package/hardverapro)
![Total current downloads on NPM](https://img.shields.io/npm/dt/hardverapro)
![node-hardverapro is still being maintained](https://img.shields.io/maintenance/yes/2020)

An API wrapper for the Hungarian classified advertisement site, [hardverapro.hu](https://hardverapro.hu) written in JavaScript

## Features

- Authentication
- Ad details
- Private messages
- Search (both ads and sellers)
- User profiles

## Installation

Using `npm`:

```sh
npm install -g hardverapro
```

## License

This project is licensed under the MIT License

repository: szkly/node-hardverapro

repo_name: szkly/node-hardverapro


text:
# Parasite

## Important Notice

Going to acquire some major new features soon...

## What Parasite does

1. Infects Elements (preferably provided by an Alchemist)
2. Enters the host and gathers information on how to mutate it.
3. Modifies it in a way that also effects children.

## Dangers

- Parasites modify **in place**, so if you plan on reusing your host then you should probably clone it.
- If parasites have faulty instructions the will be inaffective and enter *read-only* mode
- Parasitical mutations are very **unsafe** and should be used with caution to return a String
- A parasite ~is not as extensive as *Alchemist* and ~ is only aware of `Text` and `Element`
- Only Text Content and Attribute Values will be modified.

## History

- This was not introduced until v2
- In version v2.2 a slight modification was made to handle Templates internally, turns out `DocumentFragment` seemlessly integrate into the existing code without many changes (just a few characters)

## example
~~~ javascript
function genetics(value) {
		return 'INFECTED';
}

virus = new Parasite(genetics);
virus.infect(element);
~~~

## before
~~~ html

	content

~~~

##  after
~~~ html

	INFECTED

~~~

repository: Announcement/utemplate

repo_name: Announcement/utemplate


text:
# cfn-sphere
A CLI tool intended to simplify AWS CloudFormation handling.
[![Build Status](https://www.travis-ci.com/cfn-sphere/cfn-sphere.svg?branch=master)](https://www.travis-ci.com/cfn-sphere/cfn-sphere)

## Features
- cfn templates in yml or json
- build for human interaction and automation (run 'cf sync stacks.yml' triggered by a git push if you dare ;-)
- a source of truth defining cloudformation stacks with their template and parameters
- cross referencing parameters between stacks (use a stack output as parameter for another stack)
- automatic stack dependency resolution including circular dependency detection
- helper features easing the use of cfn functions like Fn::Join, Ref or Fn::GetAtt
- easy user-data definition for https://github.com/zalando-stups/taupage
- allow stack parameter values updates in command line interface
- encrypt/decrypt values with AWS KMS (https://aws.amazon.com/de/kms/)

## Documentation
**https://github.com/cfn-sphere/cfn-sphere/wiki**

## Install

### As python artifact:

    pip install cfn-sphere

## Usage

    $ cf --help
    Usage: cf [OPTIONS] COMMAND [ARGS]...

      This tool manages AWS CloudFormation templates and stacks by providing an
      application scope and useful tooling.

    Options:
      --version  Show the version and exit.
      --help     Show this message and exit.

    Commands:
      convert            Convert JSON to YAML or vice versa
      decrypt            Decrypt a given ciphertext with AWS Key
      delete             Delete all stacks in a stack configuration
      encrypt            Encrypt a given string with AWS Key
      render_template    Render template as it would be used to create or update a stack
      sync               Sync AWS resources with stack configuration file
      validate_template  Validate template with CloudFormation API

## Getting Started

### 1. Create Stacks Config
Create a YAML file containing a region and some stacks in a stacks.yml file f.e.:

    region: eu-west-1
    stacks:
        test-vpc:
            template-url: vpc.yml
        test-stack:
            template-url: app.yml
            parameters:
                vpcID: "|ref|test-vpc.id"
                dockerImageName: myapp
                appVersion: 1

### 2. Write your CloudFormation templates
Write your templates and configure them in your stacks.yml

### 3. Sync it
A simple command synchronizes your definition with reality!

    cf sync myapp-test.yml

#### 3.1 Update Stack with CLI Parameter
To update parameters of a stack defined within myapp-test.yml without having to modify the templates, simply use the `--parameter` or `-p` flag.

    cf sync --parameter "test-stack.dockerImageName=mytestapp" --parameter "test-stack.appVersion=234" myapp-test.yml

### 4. Go further

Read here to see what cfn-sphere can do for you. There are a lot of things that can help you:
**https://github.com/cfn-sphere/cfn-sphere/wiki**

## Config Reference

See the wiki to see what you can do in a stack configuration: [StackConfig Reference](https://github.com/cfn-sphere/cfn-sphere/wiki/StackConfig-Reference)

## Template Reference

Cfn-Sphere supports native cloudformation templates written in JSON or YAML, located in local filesystem or s3. There are some improvements like simplified intrinsic functions one can use. See the reference for details: [Template Reference](https://github.com/cfn-sphere/cfn-sphere/wiki/Template-Reference)

## Build

Requirements:

* python >= 3.5
* virtualenv
* pybuilder

Execute:

    git clone https://github.com/cfn-sphere/cfn-sphere.git
    cd cfn-sphere
    virtualenv .venv --python=python3.10
    source .venv/bin/activate
    pip install pybuilder
    pyb install_dependencies
    pyb

## Contribution

* Create an issue to discuss the problem and track changes for future releases
* Create a pull request with your changes (as small as possible to ease code reviews)

## License

Copyright Marco Hoyer

Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.

repository: cfn-sphere/cfn-sphere

repo_name: cfn-sphere/cfn-sphere


text:
# guld Ledger

## Creating a Blockchain With Triple Entry Accounting

### Author: Zimmi
 License: CC-BY-4.0

## Single, Double & Triple Entry Accounting

### *NOTE: Blockchains are examples of triple-entry accounting.*

|     |Error Checking|Auditing|Messaging|Example|
|-------|------|---------|---------|--------|
|Single|None|None|N/A|Assets -10|
|Double|Automatic for local book|Manual|Lossy|Assets -10 Expenses +10|
|Triple|Automatic for all books|Automated in Real-time by third parties|Redundant to Lossless|Assets -10 Expenses +10 <sign receipt>|

## ledger-cli

### [Ledger](https://www.ledger-cli.org/) is a powerful, double-entry, plaintext accounting system

![CommodityGULD](https://github.com/Alexstang/Zimmi-Slides/blob/master/Commodity%20GULD.jpg)

* Define commodities
* Automate Transactions
* Budgets and Forecasts
* Python scripts
* Accounts
 * Assets
 * Liabilities
 * Equity
 * Income
 * Expenses
 * custom

## Guld Ledger Format

### Account Format

1. A guld name
2. One of the standard accounting categories: Assets, Liabilities, Income, Expenses, Equity
3. Defined by the user

![Account](https://github.com/Alexstang/Zimmi-Slides/blob/master/Account.jpg)

### *Additionally required timestamp metadata (i.e. ; timestamp:<PHONE_NUMBER>)*

![Timestamp](https://github.com/Alexstang/Zimmi-Slides/blob/master/Timestamp.jpg)

## Guld Ledger File Format

![ZimmiLedger](https://github.com/Alexstang/Zimmi-Slides/blob/master/ZimmiLedger.jpg)

* Usually one transaction per file with the timestamp as name.
* Only one file can exist with given timestamp in given name directory.
* Transaction limit of 1/name/sec

![ZimmiTimeStamp](https://github.com/Alexstang/Zimmi-Slides/blob/master/ZimmiTimestamp.jpg)

* Timestamp metadata matches file name.
* Since metadata is signed, this ensures nonce authenticity.

## Individual Accounts

### Individual accounts are controlled by a single, registered PGP key.

![RegisterIsysd](https://github.com/Alexstang/Zimmi-Slides/blob/master/RegisterIsysd.jpg)

* Individuals apply for a name using PGP public key.¹
* Registration costs 0.1 GULD.²
* Account in GULD ledger, and 4 official sub-accounts.
 * Assets
 * Liabilities
 * Income
 * Expenses

## Group Accounts

### Group accounts are controlled by consensus of one or more registered individual PGP keys.

### Equity Example

![Equity](https://github.com/Alexstang/Zimmi-Slides/blob/master/Equity.jpg)

* Registration costs ~0.1 GULD/member.²
* Have own account in GULD ledger, and 5 official sub-accounts.
 * All Individual sub-accounts
 * Equity
* Equity
 * = Vote weight
 * determines consensus

### Group Register Example

![GroupRegistration](https://github.com/Alexstang/Zimmi-Slides/blob/master/RegisterGroup.jpg)

## Official Templates

*A transfer transaction moves Assets from one guld name to another.*

![Transfer](https://github.com/Alexstang/Zimmi-Slides/blob/master/Transfer.jpg)

*A grant transaction rewards a member for contributions to the group. Reward is both in transferable Assets and non-transferable Equity.

![Grant](https://github.com/Alexstang/Zimmi-Slides/blob/master/Grant.jpg)

*A register transaction creates a new, typed namespace in the blocktree.*

![RegistrationTX](https://github.com/Alexstang/Zimmi-Slides)

## Advanced Tools

*Automated Transactions execute every time a matching line is found in a full transaction.*

![AutomatedTX](https://github.com/Alexstang/Zimmi-Slides/blob/master/AutomatedTX.jpg)

*Budgets allow for limits to be set and enforced for each sub-account and time period.*

![Budgets](https://github.com/Alexstang/Zimmi-Slides/blob/master/Budgets.jpg)

Scripts can be embedded in ledgers, or executed as hooks by the guld filesystem.³

![Scripts](https://github.com/Alexstang/Zimmi-Slides/blob/master/Scripts.jpg)

## Summary

### Guld branch + ledger = blockchain

## End Notes

1. Name availability subject to discretion of guld support admins until official, legally compliant policy can be written.
2. Guld name registration prices as of Apr. 1 2018. Group names in table not ratio, capped at 1,000 GULD.
3. [Guld FileSystem Specification](https://guld.io/docs/guldFS-Specification.pdf) - Additional Configuration

*Scripts can be embedded in ledgers, or executed as hooks by the guld filesystem.³*

repository: Alexstang/Zimmi-Slides

repo_name: Alexstang/Zimmi-Slides


text:
GamePlay

## Project

Application to help you connect and organize fun time and play with friends. Create groups to play your favorite games with your friends with this App that has Discord authentication.

## Features

- OAuth2 Social Authentication with Discord server;
- Get user profile registered in Discord (username and avatar);
- Lists the Discord servers that the user is part of;
- Allows you to schedule matches;
- Allows you to filter matches by category;
- Share the invitation to join the user's server;
- Allows you to redirect the user to your own server;

## Technologies and Libraries

This project was developed with the following technologies/libraries:

- [Node.js v14.16.0](https://nodejs.org/en/)
- [React Native](https://reactnative.dev/)
- [Expo v4.3.4](https://expo.io/)
- [AsyncStorage](https://docs.expo.io/versions/latest/sdk/async-storage/)
- Typescript
- Context API
- Axios
- OAuth2 Discord
- Expo Authentication
- Deep Link

## Mobile devices used in development

- Android: API 29
- IOS: 14.6

## Layout

You can view the project layout through this [link](https://www.figma.com/file/MkVfL7gxlZgYGcX0X72eOv/GamePlay-NLW-Together-Copy-Copy?node-id=58913%3A83). Figma account is required to access it.

## How to run

- Clone the repository;
- Access project directory;
- Install dependencies with `yarn` or `npm install`;
- Access [Discord server](https://discord.com/developers/docs/intro) to create an application;
- Insert application name;
- On the OAuth2 page add a redirect url and select it in OAuth2 URL Generator;
- In SCOPES check the following options: identity, email, connections and guilds, then copy the generated url;
- Change the file name from `.env.example` to `.env`;
- In the `.env` file, fill in the credentials information with the generated url;
- In the app.json file, insert the `schema` item with the name of the application created on the Discord server;
- Start the expo with `expo start`, `yarn start` or `npm start`;
- To execute mobile aplication in the a physical cellphone install Expo Go or use a emulator;

## License

This project is under the MIT license. See the [LICENSE](LICENSE.md) file for more details.


text:
---
parent: Getting Started
title: Running the Samples
has_children: false
nav_exclude: false
nav_order: 1
---
# QuickStart: Deploying Infrastructure Catalog Samples

_This guide is targeted towards developers, contributors, or anyone who wants to test
out the various modules which available. We will start with the
`data-lake-on-aws` sample, and from there then you can deploy any additional examples
using the same procedure._

## Setup workstation and clone the repo

1. Start by installing the required DataOps tools.
   - Go to [https://docs.dataops.tk/setup](https://docs.dataops.tk/setup).
   - Follow the provided installation steps, including at minimum:
     Git, Terraform, Docker, Visual Studio Code
2. Clone the `dataops-infra` repo.

## Configure credentials and deploy the sample

1. Create a new file in the `.secrets` folder called `aws-credentials` and enter your AWS
   credentials.
   - _For reference, refer to the sample file: `.secrets/aws-credentials.template`._
2. In left-hand navigation pane in VS Code, expand the `samples` folder select the
   `data-lake-on-aws` sample.
3. Right-click the desired sample folder (`data-lake-on-aws` in this example) and select
   "Open in Integrated Terminal".
4. Run `terraform init` to download needed providers and then run `terraform apply` to
   deploy the infrastructure.

## Tear down the infrastructure

1. Once again, in the left-hand navigation pane in VS Code, expand the `samples` folder
   select the `data-lake-on-aws` sample.
2. Right-click the desired sample folder (`data-lake-on-aws` in this example) and select
   "Open in Integrated Terminal".
3. Run `terraform destroy` to tear down the environment.
   - When prompted, type 'y' to confirm.

## Running the 'kitchen sink' sample

> Remember: you are deploying _**real infrastructure**_ into the cloud, and those resources
> cost real money. Be sure to run `terraform destroy` to cleanup your AWS environment after
> running each deployment.

_Once you have successfully deployed the data lake sample, you are ready to deploy more
advanced infrastructures._

1. In left-hand navigation pane in VS Code, expand the `samples` folder select the
   `kitcken-sink-on-aws` sample.
2. Right-click the `kitcken-sink-on-aws` sample folder and select
   "Open in Integrated Terminal".
3. Run `terraform init` to download needed providers and then run `terraform apply` to
   deploy the infrastructure.

If needed, perform any necessary debugging until you succeed in running `terraform apply`
without errors. At any time, especially if you get stuck on a particular module, you may still be
able to run `terraform output`, which will give you an overview of the components which have
deployed successfully.

### Browsing the deployed infrastructure

Navigate to the [samples directory](https://github.com/slalom-ggp/dataops-infra/tree/main/samples)
and select from one of the samples. Each sample folder has a README file which explains
the functionality and links to readme for each of the related catalog components.

repository: alvin-mwangi/dataops-infra

repo_name: alvin-mwangi/dataops-infra


text:
See [Let's Build a Compiler](https://compilers.iecc.com/crenshaw/) by Jack Crenshaw.

This code parses expressions of the form:
```
<expression> ::= <term> [<addop> <term>]*
<term> ::= <factor> [ <mulop> <factor> ]*
<addop> ::= "+" | "-"
<mulop> ::= "*" | "/"
<factor> ::= <digit> | "(" <expression> ")"
```

repository: glyn/expr

repo_name: glyn/expr


text:
# Smileycoin SMLY

http://smileycoin.is

Follow [@OfficialSMLY](https://twitter.com/OfficialSMLY)

Copyright (c) 2014-2016 Auroracoin Developers

## What is Smileycoin?

Smileycoin is a cryptocurrency for Iceland. It is based on Litecoin and is 50% premined. The premined coins will be distributed to the entire population of Iceland, commencing on midnight 25th of March 2014.

## Community

Forums: http://smlyoraspjall.is/

Irc: #smly on freenode

http://www.reddit.com/r/smileycoin

http://www.reddit.com/r/SMLYmarket

https://bitcointalk.org/index.php?topic=1044432.0

## Developers

Developers are encouraged to create tools for Smileycoin to support the adoption of Smileycoin. Such software, e.g. for payments, will help Icelanders start using the currency in their daily lives.

Interested in helping out? Please email<EMAIL_ADDRESS>and let us know how you can help.

repository: oligeorg/SmileycoinTest

repo_name: oligeorg/SmileycoinTest


text:
Playing with mustache.js
========================

show how to integrate mustache.js with backbone.js

run
---
`$ ./serve 3000`

template file
------------
the template is located in `scripts/template/`. In main.js, it preloads
and caches the template before it initializes the application router and
Backbone.js's History.

see also
--------

* [Mustache man page](http://mustache.github.com/mustache.5.html)
* [tutorial html templates with mustache.js](http://coenraets.org/blog/2011/12/tutorial-html-templates-with-mustache-js/)

repository: crh/backbone-and-mustache

repo_name: crh/backbone-and-mustache


text:
# css-dark/

The files in this folder provide the styles for the dark theme.
Because all the css is concatenated to a single css, all dark theme
tags should be prefixed with `.dark-theme <selector>`. Note that the absence
means that the styles at the given style selector are probably not
converted to dark theme. Only color properties should be used in the
dark theme when possible.

    text area -> #222
    button area -> #333

repository: TGlas/tscript

gha_language: TypeScript

repo_name: TGlas/tscript


text:
# docker for jsk\_recognition

## Usage

Please run below in Jenkins server at JSK lab, or add it to cron job.

```bash
git clone https://github.com/jsk-ros-pkg/jsk_recognition.git
./jsk_recognition/docker/build.sh
```

branch_name: refs/heads/carma-develop