text:
# Meta
[meta]: #meta
- Name: 2023H1 Roadmap
- Start Date: 2023-01-24
- Author(s): hone
- Status: Approved
- RFC Pull Request: [#272](https://github.com/buildpacks/rfcs/pull/272)
- CNB Pull Request: (leave blank)
- CNB Issue:
- Supersedes: (put "N/A" unless this replaces an existing RFC, then link to that RFC)

# Summary
[summary]: #summary

This RFC details the first half of the 2023 Roadmap as well as changing the roadmaps to twice a year aligning with KubeCon EU and NA (CDD - Conference Driven Development).

# Definitions
[definitions]: #definitions

N/A

# Motivation
[motivation]: #motivation

The project has done annual roadmaps in the past, but they haven't been without their challenges. The items range from concrete to large themes. The larger scoped items like "Integration with the Cloud Native Ecosystem" is nebulous and not always clear what success look at the end of it. The roadmap has felt like a smaller vision document versus a set of prioritized items to be accomplished.

Without clear guidance on how to shape the roadmap, it's also been a challenge to get one out (not that we're doing great this year). We missed 2022's roadmap altogether and didn't publish one until March for 2021.

Once we did publish a roadmap, items wouldn't necessarily move forward even though we commited as a project to work on them. Items didn't always have an owner and there was no skin in the game for suggesting an idea.

In addition, we don't do a good job of reviewing our roadmap whether that's regularly through the year or at the end of the year.

As an incubation level project, there is an opportunity to broadcast announcements at both KubeCon EU and NA. As a project, we're often caught flatfooted with sharing highlights or announcements during these conferences.

# What it is
[what-it-is]: #what-it-is

## Roadmap Changes

For 2023, I want to propose trying something different this time around. The project will publish two roadmaps one for each half of the year aligned with work to be completed for KubeCon EU (2023-04-18) and KubeCon NA (2023-11-6). The goals I'm hoping to see:

- Focus - Decrease the amount we're doing as a project, so we're able to deliver on the things we commit to.
- Accountability - With that focus, we also need to be accountable for what we're putting on this list.
- Marketing - Everyone involved works hard to make this project successful. We should take time to celebrate and talk about the work being done.

### Smaller Scope

Going forward, the roadmap will account for 6 months (in this case it's just under 4 months) worth of work. This forces items on the roadmap to be smaller and concrete since they have to be something that can be accomplished in that time frame. While it was nice having the large items, they were hard to execute and it wasn't clear what the finished state looked like. Any larger piece work will need to broken down to make it on the roadmap in a 6 month chunk. It's also not too small, that some larger chunks of work can be planned. Having a second roadmap each year, also allows us to course correct mid-year.

Not only are individual items smaller, but we as a project should commit to less so they can be accomplished aren't just a bunch of empty promises. This means hard decisions will need to be made to cut highly requested features from the roadmap.

Since this is an OSS project, things that don't make the roadmap can still be pursued by others and welcome! With finite time of maintainers, there still may be limited support depending on the maintainer. Also, items can also bubble up during the next roadmap cycle and people should advocate for them in the GitHub discussion or slack.

### Ownership

In order to ensure things make progress, every item in the roadmap will have an owner from the project leadership team of TOC members or team maintainers. If someone really wants something on there, they will need to volunteer themselves to help keep it on track if no one else will. This will help keep the number of items on the roadmap from ballooning. The owner will also be responsible for keeping everyone up to date. All roadmap items should link to something to GitHub where things can be tracked.

### KubeCon Alignment

As stated above, we'll be making roadmaps with work finishing by a KubeCon event. They're coveniently around 6 months apart give or take a few weeks. As an incubation project, we're able to share project announcements at these events. This will keep the key items we're working on top of mind, and what gets finished can easily be shared. Roadmap items can also make good talk material for the maintainer track.

With how strict travel budgets are in the current economic climate, these events are one of the few times some of us can get together. Nothing can really replace in person conversations and brainstorming. These discussions can feed into the natural recap/review of the conference and as a way to kickstart roadmap review and planning.

## 2023H1 Roadmap

### Release Base Image Extension
* Owner: @natalieparellano
* Links: [RFC](https://github.com/buildpacks/rfcs/blob/main/text/0105-dockerfiles.md)

This started out as [Stack Buildpacks](https://github.com/buildpacks/rfcs/blob/main/text/0069-stack-buildpacks.md) and now Dockerfile Extensions. Significant work has already been done on this feature over the last year. This roadmap item is about seeing this work through with releasing phase 3 in both `lifecycle` and `pack`.

### Remove Stacks & Mixins
* Owner: @jkutner
* Links: [RFC](https://github.com/buildpacks/rfcs/blob/main/text/0096-remove-stacks-mixins.md)

This RFC was merged in 2021 and is a dependency on Base Image Extensions. In order to get us to 1.0, we'll need to take on some of these painful backwards breaking changes in the best way possible. This work will include the Buildpack & Platform spec changes with support in `lifecycle` and `pack`.

### Execution Environments RFC
* Owner: @hone
* Links: [RFC](https://github.com/buildpacks/rfcs/pull/274)

There has long been a desire for a "Test" support, but it's never been prioritized even though it's made the roadmap before. Not to be over ambitious, the first step is to get a RFC written and accepted.

### Project Health
* Owner: @samj1912
* Links: [Buildpacks Community Organization RFC](https://github.com/buildpacks/rfcs/pull/273)

Like other [CNCF projects](https://github.com/cncf/toc/issues?q=is%3Aissue+sort%3Aupdated-desc+%22health+of%22+-label%3A%22project+onboarding%22+-label%3A%22sandbox%22+), the project has been impacted by the VMware + Broadcom acquisition. The goal of this item is to improve the general health of the project and grow contributors back to our 2020 numbers. This inludes every team having a set of active set of maintainers and contributors, thus removing the TOC needing to step in for platform.

As for concrete items to be accomplished:

* Establish a buildpacks-community to be used as a labs/staging area to help hype up experiments that we would be otherwise wary of investing in and, if they succeed, adopt them in the main buildpacks org.
* Participate in mentorship programs to grow contributors like [GSoC](https://summerofcode.withgoogle.com/) and [LFX Mentorship](https://lfx.linuxfoundation.org/tools/mentorship/).

### Pack Test Cleaning/Optimizations
* Owner: @dfreilich
* Links: [Pack Pull Request](https://github.com/buildpacks/pack/pull/1498)

Currently, the pack acceptance tests are very complex for newcomers. In order to help with contributions, we can relax some of these tests.

# How it Works
[how-it-works]: #how-it-works

See [What it is](#what-it-is) for the bulk of the details. For implementing this plan:

* Open a PR against the [community repo](https://github.com/buildpacks/community) replacing the `ROADMAP.md`.
* As part of the regular leadership meetings we will hold check ins.
* After each KubeCon there will be a recap session and kicking off the next roadmap planning.
* In 2024, we will review how this compares to the normal annual roadmap we've traditionally done.

# Migration
[migration]: #migration

N/A

# Drawbacks
[drawbacks]: #drawbacks

- This will be more work with twice the number of roadmap plannings.
- There will be more overhead to ensure accountability.

# Alternatives
[alternatives]: #alternatives

## Do Nothing

We can continue to do the annual roadmap. This hasn't proved very successful, but we can still take the lessons learned and adjust the current process.

# Prior Art
[prior-art]: #prior-art

- [Buildpacks 2021 Roadmap](https://github.com/buildpacks/community/pull/72)
- [Rust 2021 Roadmap](https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.html)
- [TypeScript Roadmap](https://github.com/microsoft/TypeScript/wiki/Roadmap)

# Unresolved Questions
[unresolved-questions]: #unresolved-questions

- How many items should any one person be able to own?

# Spec. Changes (OPTIONAL)
[spec-changes]: #spec-changes

N/A

# History
[history]: #history

<!--
## Amended
### Meta
[meta-1]: #meta-1
- Name: (fill in the amendment name: Variable Rename)
- Start Date: (fill in today's date: YYYY-MM-DD)
- Author(s): (Github usernames)
- Amendment Pull Request: (leave blank)

### Summary

A brief description of the changes.

### Motivation

Why was this amendment necessary?
--->

repository: buildpacks/rfcs

gha_language: Shell

repo_name: buildpacks/rfcs


text:
# mOway_SW_mOwayScratchV2
Python module for writing the interface with Scratch 2.0 extension.
## Usage
The moway.hex file used is created by the mOway_FW_ScratchV2 project.
## Built With
* [blockext v0.1](https://github.com/blockext/blockext.git)
## Version
```
 5.0.1
 Platform Toolset: Python 2.7
```
## License
This project is licensed under the MIT License - see the LICENSE.md file for details

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Mule Authentication Util API

This is a utility MuleSoft API that retrieves an Open ID Connect Access Token from Salesforce by using the supplied client_id/client_secret credentials in the request

# Why?

At the time of writing, Salesforce supports only the following grant types for OAuth 2.0 Open ID Connect:

- Implicit
- Authorization Code
- Refresh token

However, the grant type "client_credentials" is currently NOT supported by Salesforce, and this is an issue for Server to Server authorization. The purpose of this application is to enable this missing functionality in Salesforce.

# Solution Overview

Please refer to the article "Enable Open ID Connect Using Grant Type client_crendentials with MuleSoft and Salesforce as IDP" in Catalyst Knowledge Hub (https://catalyst.mulesoft.com) that explains how this API works within the overall solution.

# Setup

Follow the below steps to setup the API.

1. Import of the RAML in Design Centre and publish to Exchange

Import the files under the src/main/resources/api/* into Design Centre and Publish the API spec to Exchange

2. Manage you API in API Manager

Import and manage your API in API Manager for the Production environment and save your API Autodiscovery ID

3. Create an encryption key and choose the encryption algorithm

The Global configuration elements are in the global/config.xml file. The "enc.key" global property is the one that will contain your encryption key when the application is deployed. Make sure your key conforms to the algorithm configured in the Secure Properties Config element

4. Configure your property files

The property files are present under the src/main/resources/properties folder. Change all the properties with value "changeit" with the proper value. Two important main properties are:

  * authentication.api.id: this must contain the API Autodiscovery ID configured in step 2 above
  * jwt.user, jwt.keystore, jwt.keystore.alias, etc.: those properties are related to the Salesforce user for the connected app and keystore containing the certificate configured in Salesforce to sign the JWT. You must copy the key store under the src/main/resources/keystores/salesforce folder in order to work

5. Encrypt the properties in the property files

Once a key/algorithm has been chosen, the following properties will need to be encrypted in the properties file:

  * https.keystore.password: this is the keystore used to enable SSL in CloudHub for port 8082
  * jwt.keystore.password and keystore.key.password: those properties are related to the key store and key passord for the Salesforce certificate

# Author
Roberto Oliva [Email<EMAIL_ADDRESS>

license: Unlicense


text:
Calabria-Digital-Bio
====================

Repository for my notes and computer programs written for my bioinformatics (digital biology) class.

My teammates for the class project are: Ms. Diana Medina and Ms. Selene Howe.

Our project repository is located at: /usr/local/share/digitalbiology/dbg0006. It is currently defunct.

---

# Acknowledgements

## Classmates

### Teammates
I acknowledge that I have collaborated with my project teammates Ms. Diana N. Medina and Ms. Selene Y. Howe to complete this homework. Specifically, we discussed some hypotheses for homework assigned for Thursday, June 26, 2014, and how to test those hypotheses.

	For Homework 2, we discussed different reasons for the variation between the different DNA sequences of GenomeA1, GenomeA2, and GenomeA3.

### Other classmates
I also want to thank Ms. Priyadharshini Venkat, my classmate for this course, for giving me feedback about my hypotheses and helping me to find alternate golden models for the {\it Neurospora crassa} species.

Furthermore, I want to thank Ms. Priyadharshini Venkat and Ms. Elyssa Garza for explaining Phred quality scores in the context of the FastQ format for the {\it Neurospora crassa} species.

Besides, Ms. Oneida Ibarra helped me to understand the flow of genome assembly with BLAST+ and script for converting BLAST+ output file formats to GFF3 file format.

## Class Instructor and Teaching Assistant
I also acknowledge the help that I have received from the course instructor, Prof. Rodolfo Aramayo, in getting back to my queries about the source of the reference sequence for the *Neurospora crassa* species that was provided to us on Tuesday. Prof. Aramayo also explained why the Perl scripts were for: converting BLAST+ output files in BLAST+ formats to GFF3 file format.

My teaching assistant, Mr. Ricardo Perez, has also helped me with different computing problems, and misunderstandings of genetics/genomics.

## Others
In addition, I want to thank Ms. Tess L. Pham from the Tutor Zone at Evans Library, which is run by the Academic Success Center at Texas A\&M University. Ms. Pham has tutored me about the basics of genetics and gave me feedback about the hypotheses which I proposed.

---

To be updated... To be updated... Fix this!!!

To be fixed... Must fix this!!! Will fix it.

repository: eda-ricercatore/Calabria-Digital-Bio

gha_language: TeX

gha_license_id: MIT

repo_name: eda-ricercatore/Calabria-Digital-Bio


text:
# Sails.js Edge Version [![Build Status](https://travis-ci.org/balderdashy/sails.png?branch=development)](https://travis-ci.org/balderdashy/sails)

> Disclaimer:  This branch is for core development of the framework, and is not necessarily in a stable state!
> If you'd like to contribute, please send a pull request.  If you're thinking of biting off something big, or have some questions, join us on IRC
at #sailsjs on freenode or email the Google group.

### This branch is the release candidate for Sails v0.9.0.

+ [Roadmap](https://github.com/balderdashy/sails/wiki/roadmap)

+ [Changelog](https://github.com/balderdashy/sails/wiki/changelog)

License
--

Sails is built around so many great open-source technologies that it would never have crossed our minds to keep it proprietary.  We owe huge gratitude and props to TJ Holowaychuk (@visionmedia) and Guillermo Rauch (@guille) for the work they did, as well as the stewards of all the other open-source modules we use.  Sails could never have been developed without your tremendous contributions to the node community.

The MIT License (MIT)
--

Copyright © 2012-2013 Mike McNeil

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.

[![githalytics.com alpha](https://cruel-carlota.pagodabox.com/8acf2fc2ca0aca8a3018e355ad776ed7 "githalytics.com")](http://githalytics.com/balderdashy/sails)

branch_name: refs/heads/development

gha_language: JavaScript


text:
CI configuration for iOS projects
-----------------

This is a tutorial explaining how to configure continuous integration for iOS projects from scratch. Some steps can't be followed without being granted access to certain services; request them to an iOS' technical leaders:

* [Ariel<EMAIL_ADDRESS>* [Diego<EMAIL_ADDRESS>
The following steps will guide you to setup a new project in [Bitrise](https://bitrise.io). Note that this guide is intended for standard projects, so if any custom configuration is needed some steps may change.

## Check repo files...

### Check the repository’s `bitrise.yml`.

It can be found [here](https://github.com/Wolox/ios-base-project/blob/master/bitrise.yml) in the `ios-base-project` root directory.

Replace `REPO_SLUG`, `BITRISE_PROJECT_PATH` and `BITRISE_SCHEME` values with your app’s values.
Keep in mind that the bitrise steps versions may be outdated, so check the [latest versions](https://github.com/bitrise-io/bitrise-steplib/tree/master/steps) inside each steps folder and update the file accordingly. Example: if `bitrise.yml` contains a step<EMAIL_ADDRESS>check in that folder, in the step `script` if `1.1.3` is the latest version.

Our bitrise scripts will use [Fastlane](https://github.com/fastlane/fastlane), this gem is already added in the [Gemfile](https://github.com/Wolox/ios-base-project/blob/master/Gemfile). You can run `fastlane init` to initialize Fastlane with a basic configuration.

## Check configuration files encryption...

This step is optional and only useful if you need to encrypt files to be used in Bitrise. As long as you use CI only for compiling and running tests, this step will not be necessary. Instead, if you configure CI for building the application (for example for distribution) you will need to upload the encrypted `.xcconfig` files.

The provided `bitrise.yml` is not configured for encryption, so in case your project requires it follow these steps:

### Encryption

If you need to use any secret configuration keys in the Bitrise build, encrypt the `.xcconfig` files with those keys.

```
# Put all the files in a tar file
tar cvf secrets.tar file1 file2

# Encrypt the tar file
openssl aes-256-cbc -k "password" -in secrets.tar -out secrets.tar.enc
```

### Decryption

Add this as first step of the `bitrise.yml`:

```
    -<EMAIL_ADDRESS>        title: Decrypting files...
        inputs:
        - content: openssl aes-256-cbc -k "$ENCRYPT_PASSWORD" -in secrets.tar.enc -out secrets.tar -d && tar xvf secrets.tar
```

Don’t forget to include `ENCRYPT_PASSWORD` as explained in [Configure App Environment variables](#configure-app-environment-variables)

## Create Bitrise app...

### Log in to [Bitrise](https://www.bitrise.io/) using your Wolox's github account.

If you’re not added to the `Wolox` organization, you should ask the technical leader to do so.

### Add application

In Bitrise dashboard, press "Add new app" to start the process.

### Choose project’s repository

Before starting, make sure `Wolox` is selected in the "Add new app to" option in top left.

![choose organization](./resources/br1.png)

From the list of platforms, choose `Github`. Below, in the left part of the screen you can see a list of github organizations you contribute to. Choose `Wolox` (or the organization the repository is under), and then at the right choose the repository you want to integrate.

![choose project](./resources/br2.png)

### Setup repository access

Select `auto-add SSH Key`. The key should be added automatically after a moment. If it doesn’t work, you may need to do it manually.

NOTE: Only Github admins can automatically add the SSH key in this step. In case you have no access, skip this step and ask your TL to do it.

![choose project](./resources/br3.png)

### Validation setup

Choose the main branch of your project (master or development usually). Bitrise will scan the branch to check for the correct configurations. This takes about 5 minutes.

### Project build configuration

Select iOS. Verify that the correct XCode stack is selected and confirm.

![choose project](./resources/br4.png)

### Webhook setup

Please note this can only be done by a repository administrator.

Select "Register a new webhook for me". It will allow Bitrise to know when a `push` / `pull request` has been made, so it can test it.

It can be done from the Code tab in the project’s dashboard. Under “webhooks”, there’s a webhook URL which you can add to your Github repository following [this guide](https://github.com/bitrise-io/bitrise-webhooks#github---setup--usage).

### Finish configuration

Select "We’ve kicked off your first test build for you!" to continue. Bitrise will run a build at this step, you should cancel it since it runs with another configuration, thus it will fail.

![choose project](./resources/br5.png)

## Configure Bitrise’s `bitrise.yml`

When Bitrise builds trigger, they look for the configuration in the web’s `bitrise.yml`. This file should call the one from our repository.

For this, go to `Workflow`, inside the project's bitrise page. There select `bitrise.yml` and replace the contect of the file for this:

```
format_version: 1.4.0
default_step_lib_source: https://github.com/bitrise-io/bitrise-steplib.git
trigger_map:
- push_branch: master
  workflow: ci
- pull_request_source_branch: "*"
  pull_request_target_branch: "*"
  workflow: ci
workflows:
  _run_from_repo:
    steps:
    -<EMAIL_ADDRESS>        run_if: '{{getenv "SSH_RSA_PRIVATE_KEY" | ne ""}}'
    -<EMAIL_ADDRESS>{}
    -<EMAIL_ADDRESS>        title: Extracting Bitrise configuration from repo
        inputs:
        - content: |-
            #!/bin/bash
            set -ex
            bitrise run "${BITRISE_TRIGGERED_WORKFLOW_ID}"
  ci:
    after_run:
    - _run_from_repo
    steps:
```

## Configure App Environment variables

In the `Workflow` menu, select `Env Vars` for private repositories or `Secrets` for public ones. Add the keys and values of the environment variables that will be needed for bootstrapping, testing and all other actions or steps that will be run according to the repo's `bitrise.yml`.

If you don't know what these Env Vars are, ask your TL to give you access to them. Just as reference, the variables you will need to set are:

```
- GITHUB_ACCESS_TOKEN
- KEY_PASSWORD
- CARTHAGE_CACHE_BUCKET_NAME
- AWS_REGION
- AWS_ACCESS_KEY_ID
- AWS_SECRET_ACCESS_KEY
- RUNNING_ON_CI
```

Then, check that for every Env Var, you have the option `Replace variables in inputs?` enabled.

To have `codestats` reporting in your project, first ask an administrator to add the project to codestats and add both the `CODE_STATS_TOKEN` and `CODE_STATS_URL` of the project as an environment variable.

## Run build manually

To check that everything works correctly, you should run a build manually in your default branch.

![choose project](./resources/br6.png)

For this, go to `Start / Schedule a build`, inside the project's bitrise page. Select your default branch and confirm.

**Important**: if your build fails because of a module that's missing (`no such module '<ModuleName>'` error, for example), there's a big chance it's related with `carthage_cache`. To solve this:
* Check that you have your `carthage_cache` properly set up. If not, go through the setup process described in [its repo](https://github.com/Wolox/carthage_cache#setup).
* Try force-publishing a new build. You can easily do that with `carthage_cache publish --force`.

That will surely take care of these types of errors.

## Add bagdes to README

Badges for bitrise and codestats can be added from:

### bitrise:

Go to the project in bitrise and tap on the badge next to the project's name:

![choose project](./resources/br7.png)

In the new window that opens, select format `Markdown` and copy the "Embed" content. Paste this in the project's README badges section.

### codestats:

Paste this in the project's README badges section.

```
[![Codestats](http://codestats.wolox.com.ar/organizations/wolox/projects/project-name/badge)](http://codestats.wolox.com.ar/organizations/wolox/projects/project-name/badge)
```

Replace `project-name` with your project's repository name.

repository: Wolox/tech-guides

repo_name: Wolox/tech-guides


text:
[![Stories in Ready](https://badge.waffle.io/HRR2-Brainstorm/Brainstorm.png?label=ready&title=Ready)](https://waffle.io/HRR2-Brainstorm/Brainstorm)
Brainstorm
==========

brainstorming app

##Getting Started

serve index.js with nodemon (page will reload on server and client files changes)

`gulp`

run *client side* tests automatically whenever files change

`gulp karma-auto`

run server side tests one time

`npm test`

set up automatic jsx compiling on save:

first install react tools (if you have not already may need to run as sudo)

`npm install -g react-tools`

then run from the root of the application

`gulp jsx-auto`

repository: Cheerazar/Brainstorm

repo_name: Cheerazar/Brainstorm


text:
# Computer Graphics Project
![Organization](https://img.shields.io/badge/FEUP-MIEIC-red)

- **Short Description**:
- **Environment**: Any
- **Tools Used**: JavaScript, WebGL, CGF
- **Institution**: [FEUP](https://sigarra.up.pt/feup/en/web_page.Inicial)
- **Course**: [MIEIC](https://sigarra.up.pt/feup/en/cur_geral.cur_view?pv_curso_id=742&pv_ano_lectivo=2019)
- **Curricular Unit**: [CGRA](https://sigarra.up.pt/feup/pt/ucurr_geral.ficha_uc_view?pv_ocorrencia_id=436438) (Computer Graphics)

## Github Page
[Explore the project](https://telmooo.github.io/feup-cgra/proj/)

## Group Members
- Telmo Baptista<EMAIL_ADDRESS>
## Program usage
To host the project, it will be needed to setup a server.
This can be done in multiple ways, and it's up to you to decide which one you use.
As an example you can use Python to host the server by doing in the project directory:
```shell
python -m http.server 8080
```
For this you must have Python installed on your computer, and a browser compatible with WebGL, such as Google Chrome, Mozilla Firefox, etc.

## Description
The aim of the project was to develop a basic scene of a zeppelin overflying a terrain, the zeppelin has basic movement (acceleration and rotation) and can release supplies.

## Controls
Apart from the GUI controls, there's some keyboard and mouse input controls to control the scene:
- **Mouse movement** - Move the user's POV
- **CTRL + Mouse Movement** - Zoom in/out
- **W** - accelerate
- **S** - brake
- **A** - turn left
- **D** - turn right
- **R** - reset vehicle to center and supplies
- **L** - drop supply

## Screenshots
### Vehicle Model
![Vehicle Model](./screenshots/proj-t7g10-1.png)

### Vehicle Supplies
![Vehicle Supplies](./screenshots/proj-t7g10-3.png)

### Flag Motion
![Vehicle Flag](./screenshots/proj-t7g10-5.png)

## Extras
- The flag has an wire connecting to the zeppelin, the wire is also animated accordingly
- Similar to the rudders, the flag also is pushed on the opposite direction the vehicle is turning
- Each cube map has its own sea level, so the height of the ceiling also varies, this is to provide a better aspect of the scene at ground level
- There's a simple concept of friction applied on to the vehicle that will make the vehicle slowly stop accelerating and rotate if there's no user inputs to do so

repository: Telmooo/feup-cgra

repo_name: Telmooo/feup-cgra


text:
# Knuth Rest-API

## Description

The Knuth Rest-API is a powerful RESTful service engineered with Node.js and Express. Its primary purpose is to facilitate seamless interaction with the Knuth Bitcoin Cash (BCH) blockchain. With its efficient use of the memory cache module, this API significantly enhances request efficiency and overall performance. Configuration details such as cache duration and server port are managed flexibly through environment variables.

## Setup and Installation

1. Clone this repository to your local machine.
2. Install dependencies with the command `npm install`.
3. Configure environment variables in the .env file for personalized settings: `cp .env.example .env`
3. Initiate the server using `npm start`.

## API Endpoints

The Knuth Rest-API encompasses various API endpoints corresponding to methods in the Chain class. These endpoints facilitate operations such as retrieving the last block height, block headers (by height or hash), specific blocks (by height or hash), transactions (by hash), and transaction positions (by hash).

## Usage Considerations

Please note that while this repository is fully functional, it's primarily configured for learning and exploration purposes. For production use, further optimization and security enhancements are recommended.

## Contributing

We welcome contributions from the developer community. If you're interested in enhancing the functionalities of the Knuth Rest-API or have some useful insights, feel free to submit a Pull Request or open an Issue on GitHub.

repository: k-nuth/rest-api

repo_name: k-nuth/rest-api


text:
---
title: Rule GraveyardTimeMS
searchTitle: Lua Rule GraveyardTimeMS
weight: 1
hidden: true
menuTitle: Rule GraveyardTimeMS
---
## GraveyardTimeMS

This represents a GraveyardTimeMS Rule
```lua
Rule.GraveyardTimeMS
```

repository: xackery/eqquestapi

repo_name: xackery/eqquestapi


text:
Hailing our community as “a piece of paradise,” the article highlights our unique luxury offering and proximity to Cancun as our chief selling points, gushing that La Amada “captivates with white-sand beaches, a sprawling fairway, and unparalleled privacy–all a stone’s throw from bustling Cancun.”

> *Idyllic–that’s the word that comes to mind when arriving at La Amada Residences, a superb property composed of 215 luxury condominiums spread out across eight freestanding buildings in picturesque Playa Mujeres, Mexico.*

From the sweeping views to the spacious layouts, Modern Luxury praises our condominiums as “blissful beachfront living quarters” perfect for entertaining, with high end finishes and the option to have La Amada’s designers “fully furnish your new digs in luxe style.”

Our stunning array of amenities also receives enthusiastic praise from the luxury lifestyle publication, which proclaims that our newly renovated Beach Club with infinity pool, swim-up bar and private cabanas, state-of-the-art fitness center, rooftop pools, and 18-hole Greg Norman Golf Course is a “posh paradise” that would “leave little reason to venture off-site.”

Read the full article [here](https://digital.modernluxury.com/publication/?i=527056&ver=html5&p=118).

repository: CarlosContrerasH/la-amada

repo_name: CarlosContrerasH/la-amada


text:
dlm-clf-coswara-c19

DEEP LEARNING MODEL OF COSWARA PROJECT'S COVID-19 DATASET

  This work conforms to an assignment whose objective is to build a deep learning model using the Coswara project's Covid-19 dataset. This is bascially a multiclass classification problem wherein the target variable called "covid_status" consists of 7-classes. Due to time crunch, I have reduced this 7-class classification task to an "effcective" 2-class (binary) classification task. Due to heavy class imbalance even in the "effective" binary problem, I have resorted to the use of the SMOTENN class from the combine module of the imbalanced-learn library.

INTERACTIVE NOTEBOOKS

  1. [Effective Binary Classification (deep learning) Model - Binder Link](https://mybinder.org/v2/gh/Tirthankar-Dutta-2016/dlm-clf-coswara-c19/1b8b41d7f3071f6469b7131c93e388a10a670ea4)

### NOTE: Do not run the interactive notebooks on [Binder](https://mybinder.org) as training the deep learning models are very slow.

TO DO LIST

  1. Reduce the original 7-class classification task to a 4-class classification task and solve it using Keras deep learning library.
  2. Approch the full 7-class classification task.
  3. Use Pytorch to address the 2-, 4- and 7-class problems.

branch_name: refs/heads/main


text:
# Spaceship Showdown
This was made for my Game Technology class. This version was completed at 2/25/2021.

In this game, you can play as either the Reklack or the Tempotera and fight against a Reklack or Tempotera. The game supports 2 players, and has a rudimentary AI system.
The Reklack can shoot magnetic mines or a wild engine that will latch onto your opponent and make them lose control. The Tempotera can shoot missiles or travel back in time 1 second.

Each ship has a certain amount of crew, and once a ship has no more crew, it is defeated. The ships also have battery, which is used for their attacks. Battery regenerates over time but it might be a good idea to partition it.

## Implementation
This game was made in Godot.

The sprite art was made by me in Piskel.

The font "airtoumcommodorishfont" was made by me (Airtoum) with Fontstruct.

## References
This game was heavily inspired by Star Control II.

This article by Alan Wolfe came in handy: https://blog.demofox.org/2017/10/01/calculating-the-distance-between-points-in-wrap-around-toroidal-space/

The Godot documentation was exteremely useful.

I looked at the Godot Engine Q&A a bunch.

The r/Godot Subreddit was occassionally useful.

## Future Development
I might make the AI better; there's some math that's wrong with it and it's overall very simplistic.

I would also probably add more ships to play as.

I would also finally add some tiny white squares in the background too for stars.

## Created by
Airtoum


text:
# ocaml-dht

OCaml bindings for [jech/dht](https://github.com/jech/dht), a tiny and efficient
C library used to access the BitTorrent DHT.  This project used to contain a
pure OCaml implementation of the DHT extracted from MLdonkey, but it was too
unstable for heavy-duty use so it has been replaced by these bindings.  The pure
OCaml implementation might return if I can fix it.

## Installation

```bash
make
make install
```

More docs to come once this is more stable.

### Documentation

See [online](https://nojb.github.io/ocaml-dht).

### Usage

See
[find_ih.ml](https://github.com/nojb/ocaml-dht/blob/master/lib_test/find_ih.ml)
for a very simple example of how to use the library.

### LICENSE

MIT.

## Contact

Nicolas Ojeda Bar at<EMAIL_ADDRESS>

repository: nojb/ocaml-dht

gha_language: C

repo_name: nojb/ocaml-dht


text:
# SI 506: Problem Set 02

## This Week's Lab Exercise

This week's problem set includes five (5) problems that work with functions, parameters, exceptions,
 and conditionals. You will construct three (3) functions from scratch, debug a function, and
 practice calling functions.

## 1.0 Problem 01 (20 points)

Implement the `addition()` function by replacing the `pass` statement with the appropriate code
block. Read the function docstring for additional implementation details.

:bulb: Don't forget to fill out the function arguments.

When you are finished with the `addition()` function, uncomment the `print()` statement to see if it
works. It should return 15.

## 2.0 Problem 02 (20 points)

First, analyze the `filter()` function and look at its docstring, arguments, and code body. Then,
uncomment the `print()` statements below the function one at a time.

The first `print()` statement will throw an exception. The second `print()` statement will fail
silently (in other words, the code will work, but not produce the desired output). Fix both errors
by modifying the code in the `filter()` function.

The first test should return as too long, and the second should return the initial string.

:warning: Do not modify any of the `print()` statements.

## 3.0 Problem 03 (20 points)

Implement the `umich_email_detection()` function by replacing `pass` statement with appropriate
code block. Read the function docstring for additional implementation details.

Test your code by uncommenting the two `print()` statements.

:bulb: You will need to use a conditional statement.

:bulb: Use a string method to identify which strings end with<EMAIL_ADDRESS>A list of string methods
is available [here](https://www.w3schools.com/python/python_ref_string.asp).

## 4.0 Problem 04 (20 points)

Put together what you've learned so far by writing a function from scratch that fulfills the
following specifications:

```python
"""
Function name: count_words_or_lines

Parameters:
    string (str): A string that will be operated upon.
    operation (str): Accepts either 'lines' or 'words'. Should have a default value of 'words'.

Returns:
    int: The number of lines or words in <string>, depending on the choice of operation.

Explanation:
    You should use conditionals to determine what is returned by this function:

    If <operation> is 'words', return the number of words in <string>.
    If <operation> is 'lines', return the number of lines in <string>.
    If <operation> is neither, return 'Choose a correct operation'.
"""
```

## 5.0 Problem 05 (20 points)

### 5.1 SET UP

You will work with the University of Michigan mission statement for Problem 5. The `mission`
variable contains the mission statement string.

```python
mission = """The mission of the University of Michigan is to serve the people of Michigan
and the world through preeminence in creating, communicating, preserving and
applying knowledge, art, and academic values, and in developing leaders and
citizens who will challenge the present and enrich the future."""
```

### 5.2 Problem

Using your `count_words_or_lines()` function, determine the number of words and lines in the
University of Michigan mission statement (provided below) and assign those numbers to `num_words`
and `num_lines`, respectively (replace '-999'). Also, determine the number of characters in
`mission` and assign it to `num_chars`.


text:
# CSYE-7220 Project - Twitter Clone

## Steps to run the project locally on your machine:
    Pre-requisites: Python, pip, nodejs, npm and docker (for docker toolbox, modify the localhost url in the backend and frontend applications with docker-machine-ip, if necessary)
* Dowload/Clone this repository
* Go inside LocalMachine_Deployment folder and click the OneClickDeployAll.cmd file to have the entire application running in a single click !
    * (If you face any issues, please refer to the type commands manually.txt file to manually enter the commands)
* Wait for the react development server to start (1 min) and go to localhost:3000 to access your application

## Steps to run the project on Google Cloud:
    Pre-requisites: (if not done already)
    1. Create a Google cloud account (if not done already), install Google Cloud CLI, run gcloud init to configure (create new project)

    2. Copy the project id and paste inside /Terraform/providers.tf.

    3. Run the command gcloud config set project <project-id> to let the cli know that you're currently working on this project. Get your project ID from Gcloud console

    4. Go to your gcloud console and search Kubernetes clusters, then click enable kubernetes services (requires billing), if not done already

    5. Run the command "gcloud auth application-default login" in a terminal to authorize.

* Dowload/Clone this repository
* Go inside Cloud_Deployment folder and click the OneClickDeployAll.cmd file to have the entire application running in a single click !
  * (If you face any issues, please refer to the type commands manually.txt file to manually enter the commands)
* Go to your gcloud console, search kubernetes engine -> go to services and ingress -> get the public IP of the React frontend service and use it to access the application. (Note: It takes 10 minutes for everything to work perfectly after succesfull deployment. If GCloud console says doesn't have minimum availability, refresh the page)
* Go into Terraform folder, open a cmd and type terraform destroy to destroy these resources.

## About the Application

## Technology Stack used:
| Microservice | Language | Function | Port     | UseCase       |
|-------|:-----------|:----------------------------- |:------------| :-----------|
| Frontend | React | Users see this beautiful frontend | 80(nginx) | Responsive screen supports mobile and Desktop users both alike |
| Backend | Python | Atomic addition to database | 5000 | reduces the write requests on database |
| API Gateway | Flask | Used as a gateway from frontend, has all API's | 5000 | Exposes various enpoints and implements JWT authorization |
| Business | Python | Censors obscene tweets | 5000 | Business use case: to censor all offensive tweets |

## Architecture Design
![](https://github.com/vikramzone/devops_final_project/blob/main/Images/Architecture.png)

## Infrastructure as Code - Terraform
* Created Kubernetes cluster on Google Cloud Platform
* Created Node pools in the Kubernetes cluster for running various implementations of k8s
* Created S3 buckets in Amazon Web Services Cloud
* Attached required policies to S3 bucket to list, get and put objects uploaded by user
[Terraform Repository](https://github.com/vikramzone/devops_final_project/tree/main/Cloud_Deployment/Terraform)

## Logging & Metrics: Prometheus and Grafana
* Used Prometheus and Grafana for monitoring of metrics and logs
* logged the metrics using prometheus and further used grafana as a dashboard for
* Able to monitor all traffic from pods, nodes and cluster
* To be able to get logs to Gafana we need to add Prometheus as a datasource in grafana

![](https://github.com/vikramzone/devops_final_project/blob/main/Images/monitoring.png)

## Cloud Services: AWS,GCP Hybrid cloud services
* Used GCP to run kubernetes cluster to provision all microservices
* Used AWS to create buckets to store images

# Twitter Microservice:
API Impementation with `Flask` and Programming language : `python` for the backend microservices
UI Impementation with `React` and Programming language : `javascript` for the frontend microservice

Application functionalities used:
1. JWT - for authenticating users
2. like/comment - for liking and commenting on others tweets
3. Responsiveness - Mobile and Web browser compatible
4. Censor offensive tweets - used Python library for censoring offensive tweets
5. redis cache - reduces reads/writes on database
6. mongodb - for saving user data
7. docker - to containerize microservices
8. JMeter - for load testing
9. putObject/getObject policies to S3worker microservice - for file upload/delete purpose to S3


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [0.9.0] - 2020-01-02

### Added

- Added Shadow devices
- Added option to clear bindings
- Added Filters for plugins
- `Button to Filter`: Allows toggling of a filter using a button
- `Axis to Filter`: Allows toggling of a filter using an axis
- Added device cache allowing configuration of disconnected devices
- Added per input blocking for supported providers
- Provider Report now contains `ErrorMessage` property. If the provider is not live, this should contain a string indicating why
- [Tobii Provider] If IsLive is false, now reports reason in ErrorMessage
- [SpaceMouse provider] IsLive is always true, as HID is always present
- [MIDI provider] IsLive is always true, as MIDI is always present
- [TitanOne Provider] IsLive now reflects connected status of device
- [TitanOne Provider] Reports 0 devices if IsLive is false
- [vJoy Provider] IsLive now reflects whether driver is installed
- [Interception Provider] IsLive is false if no devices are found, assumes driver is not installed

### Fixed

- Child profiles now properly inherit all parent devices. Fixes crash on activating profile
- IOWrapper device list is now refreshed every time devices are queried

### Changed

- Updated to IOWrapper v0.11.2
- [Interception Provider] Blockable property of BindingDescriptor now indicates if input is blockable or not. This is controlled by whether BlockingEnabled in the settings file is true or not
- [XInput Provider] Only show Xinput devices in ProviderReport that are currently connected
- [DS4WindowsApi Provider] Only show DS4 devices in ProviderReport that are currently connected
- [SpaceMouse Provider] Only show SpaceMouse devices in ProviderReport that are currently connected
- [Tobii Provider] IsLive now reflects state of driver
- [Tobii Provider] Only show Tobii devices in ProviderReport that are currently connected
- [ViGEm Provider] Do not show devices if Bus Driver not installed

### Removed

- [Interception Provider] BlockingControlledByUi setting removed

## [0.8.0] - 2019-07-27

### Added
- Material design
- Quick access button to add new profile
- Profile overview in the main window
- Added save button to profile window
- Added Anti-Deadzone helper
- Added Anti-Deadzone option to AxisToAxis plugin
- Added ButtonToEvent plugin
- Added input validation for plugin values

### Changed
- Updated to IOWrapper v0.10.5
- `Button to Axis` parameters changed to two axis values and option for initialization
- Redesigned main window dashboard
- Redesigned profile window
- Show active profile in process bar
- Replaced menu with toolbar in main window
- Replaced dialog windows with proper dialogs
- Replaced menu with toolbar in profile window
- UCR Unblocker now uses the current directory as default
- Sensitivity to Axis Merger plugin added
- Improved circular deadzone calculation

### Removed
- Removed states

### Fixed
- Sum Mode in Axis Merger plugin no longer overflows
- Unblocking no longer crashes if the UCR path has spaces
- Bind Mode button now only responds to mouse down and not mouse up (Fixes binding Space bar re-triggering Bind Mode on release)

## [0.7.0] - 2019-01-03

### Changed

- `Button to Axis` parameters changed to two axis values and option for initialization
- Plugin updates are now of type short instead of long. Some operations are performed using int, to avoid wrap-around or crashes.
- Subscription and Bind Mode callbacks are now executed as Tasks and are an Action<short> rather than dynamic
- Default blocking to true while UCR GUI does not support selecting block

## [0.6.0] - 2018-12-03

### Added

- Added bind mode for inputs

### Changed
  - Updated to IOWrapper v0.9.11

## [0.5.2] - 2018-10-28
### Fixed

- Values other than 0 or 50 for DeadZone should now work properly - Maximum deflection should now be achievable again

## [0.5.1] - 2018-10-28
### Added
- Interception Provider: Duplicate devices now have #2, #3 etc at end of name to differentiate them
- You no longer put a Provider into Bind Mode, you put a Device into Bind Mode (Bind Mode is still not implemented on the front end)
- "Provider Libraries" to simplify writing of new providers
- Rewritten DirectInput and XInput providers using new Provider Libraries
- Unit tests for Provider Libraries

### Fixed
- Interception Provider: Should no longer crash on startup when there are multiple identical devices.
- Interception Provider: Keyboard keys are no longer inverted (Press is now press, release is now release)
- Interception Provider: When both X and Y movement was received (ie diagonal movement), Interception would only process X and ignore Y.
- Fixed the MVVM for the main window

### Removed
- IOWrapper: All code from ProviderInterface that was not related to the interface itself was removed (ie Old helper libraries removed)

## [0.5.0] - 2018-10-08
### Added
- `Buttons to Axis` plugin
- Invert output to `Button to Axis`
- `Button to Buttons (Long Press)`
- Reset button for `Delta To Axis` relative mode
- DLL blocking detecting and unblocking
- Appveyor build server setup

### Fixed
- Allow `+` and `-` to be typed into plugin decimal inputs
- nuke restore task
- nuke versioning task

### Removed
- AxisToAxisCumulative, AxisToDelta, ButtonToButtonsLongPress and DeltaToAxis plugins were removed from the UCR repo and moved to the UCR-Plugins repo
- Cake build script

## [0.4.0] - 2018-09-03
### Added
- Inputs and outputs now support live preview when a profile is active
- Added circular dead zone feature
- `Button to Axis` has absolute value to support Xbox triggers
- `Axes to Axes`: Maps a stick to another stick, with optional circular dead zone which acts on both axes
- `Axis to Axis (Cumulative)`: Cumulatively move the output axis with the value of the input axis
- `Axis to Delta`: Joystick type axis to Mouse type axis
- `Delta to Axis`: Mouse type axis to Joystick type axis
- IOWrapper: Complete Delta Axis implementation for mouse support
- IOWrapper: Interception devices now show `K:` or `M:` prefix to aid in identification
- IOWrapper: Interception support for horizontal wheel

### Changed
- Updated to IOWrapper v0.5.7

### Fixed
- Fixed wrapping errors for invert, dead zone and sensitivity settings
- IOWrapper: Interception provider, fixes to device enumeration - should now find PS/2 and built-in devices
- IOWrapper: Interception mouse wheel fix
- IOWrapper: ViGEm DS4 DPad fixed
- IOWrapper: ViGEm Xbox triggers fixed

repository: INCENDE/UCR

gha_language: C#

repo_name: INCENDE/UCR


text:
Vangogh Core Template
----

Vangogh uses the `html/template` library in implementing the render engine.

The core render engine assumes a specific layout structure for template definitions.
The root template is `page`. The current template generates valid HTML5 markup.

When adding custom themes using the core render engine, the developer

* Must keep any and all files in the `view` subdirectory where a `content` template
  is defined -- the render engine assumes these file paths as constants. For sake
  of simplicity, changes should be made directly in these files, changing the `content`
  template implementation. The `content` template should not be deleted.
* May replace the `page` template implementation details, as long as the `content`
  template is still called. The minimal `page` template is:
  ```
  {{- define "page" -}}
  {{- template "content" . -}}
  {{- end -}}
  ```

repository: minkezhang/vangogh

repo_name: minkezhang/vangogh


text:
DataGraph Structure
-------------------

In addition to the [complex property types (`List`,`Map` and `DomainType`)](./types.html) we support another, partially self-describing
data structure as output format of our data queries which we call data graph.

On the java side the data graph is represented as de.quinscape.exceed.runtime.component.DataGraph instance, for Javascript
it is a plain JSON structure.

Example:

```
{
    "type" : "OBJECT" | "ARRAY",
    "columns" : <map of column descriptors>,
    "rootObject" : <object or array>,
    "count" : <row count>,
    "qualifier" : [qualifier-string]
}
```

The `type` property contains either the value "OBJECT" or "ARRAY", describing the nature of the `rootObject` object and the exact
meaning of the `column` map which contains property models in any case.

ARRAY Graphs
------------

For data graphs of type "ARRAY", the root object is an array of complex objects. Each property of those complex objects has
an entry in the columns map.

```
{
    "type" : "ARRAY",
    "columns": {
        "name": {
            "name": "name",
            "type": "PlainText",
            "domainType": "Foo",
            "data": 1,
            "config" : {
                "queryName" : "q"
            }
        },
        "num": {
            "name": "num",
            "type": "Integer",
            "domainType": "Foo",
            "data": 2,
            "config" : {
                "queryName" : "q"
            }
        }
    },
    "rootObject": [
        {
            "name": "TestFoo",
            "num": 123
        },
        {
            "name": "TestFoo #2",
            "num": 234
        }
    ],
    "count" : 2
}
```

The columns map describes two properties `name` and `num` which are `PlainText` and `Integer` respectively. For queries,
the column property will also contain a `domainType` field to mark the property as originally belonging to that domain
type. The name field will reflect the originalname within the domain type in that case (while the columns key always
describes the column name as it is for the current `rootObject`).

Query graphs will also contain an `queryName` config value describing the type name or alias the column belongs to
within the query (if the query executor supports that).

In case of a paginated result graph, the `count` field contains the number of result rows available.

OBJECT graphs
-------------

Data graphs of type "OBJECT" have a single complex object as `rootObject`. They can have a single column "*" in which
case all properties of the object will be of that type (Java Map<String,T> equivalent). Otherwise each column entry has
its own type identified by its name. It is basically an unnamed ad-hoc complex object -- as opposed to the domain types
themselves which are named complex object definitions.

Self-describing
---------------

A data graph that only contains simple properties is self-describing in terms of exceed types in any exceed application.
It already might reference application specific domain types in its `domainType` attributes though. The structure of the
rootObject is still unambiguous though.

A data graph might also contain embedded domain objects of an application-specific domain type. The structure of a
`rootObject` with embedded application-specific domain types is only known within that application.

In so far you should proceed with utmost care if you exchange data graphs between different applications or application
versions. Make sure that the domain types contained really mean what you think they mean.

repository: quinscape/exceed

repo_name: quinscape/exceed


text:
advertising-lambda-app
======================

A Lambda Architecture sample to be used on Azure HDInsight (or the Hortonworks sandbox).

The main components are:

* **HBase** database for realtime & batch writes
* **Apache Storm** Trident for realtime computation
* **Apache Pig** for batch computation
* **NodeJs** for dashboards
* **Apache Kafka** for ingestion (optional)

### Create HBase table
```
hbase shell
create 'advertising', 'bulk', 'realtime'
```

### Copy the HBase config file
```
scp USERNAME@CLUSTERNAME-ssh.azurehdinsight.net:/etc/hbase/conf/hbase-site.xml ./conf/hbase-site.xml
```

### Compile & Submit the Apache Storm topology
```
mvn clean package
scp target/advertising-lambda-app-1.0-SNAPSHOT-jar-with-dependencies.jar USERNAME@CLUSTERNAME-ssh.azurehdinsight.net:advertising-lambda.jar
storm jar advertising-lambda.jar net.serrate.advertising.storm.AdvertisingTridentTopology config.properties
```

### Execute the pig script
```
scp hadoop/advertising-script.pig USERNAME@CLUSTERNAME-ssh.azurehdinsight.net:advertising-script.pig
pig advertising-script.pig
```

### Credits
* The dashboard has been based on the work of: https://github.com/Blackmist/hdinsight-eventhub-example
* The advertising example has been based on the great book _Storm Blueprints: Patterns for Distributed Real-time Computation_ by P. Taylor Goetz and Brian O'Neill

repository: mserrate/advertising-lambda-app

repo_name: mserrate/advertising-lambda-app


text:
# logs-analysis

This project is for logs analysis of a news website. The logs are produced by the website and stored in a postgresql database. We design a class that could finish the analysis of logs. We first use a script to call a method of the class for creating views in the database. Then we use a script to call several methods of the calss to finish the analysis. The analysis tries to answer the following three questions:
1. What are the page views for 3 most popular articles?
2. What are the page views for most popular authors?
3. List the days on which the error rate is more than 1%.

## Getting started
You need to have the postgresql database with the log data to run this project. You also need to install python2 and the python module - psycopg2. To get started, clone the repository to run the application locally on your computer.

    $ git clone https://github.com/mediaProduct2017/logs-analysis.git

## Usage
1. Open the directory "logs-analysis" and run the script "create_view.py" to create views in the database.

       $ cd logs-analysis
       $ python create_view.py

2. Run the script "analysis.py" to conduct the log analysis.

       $ python analysis.py

3. Open the text file "results.txt" in the directory and you'll see the answers for the 3 questions.


text:
# Breadth First with Graphs
[Table of Contents](../../../README.md)
## Challenge 36

Implement a breadth-first traversal on a graph.

## Features
- [x] Extend your graph object with a breadth-first traversal method that accepts a starting node. Without utilizing any of the built-in methods available to your language, return a collection of nodes in the order they were visited. Display the collection.

## Examples

`Input:`

![input](../../../assets/breadth_first/input1.png)

`Output:`
```
 [Pandora, Arendelle, Metroville, Monstroplolis, Narnia, Naboo]
```
`Input:`

![input](../../../assets/breadth_first/input2.png)

`Output:`
```
[Bob, Tom, Jon, Sam, Joe]
```

---
## Approach & Efficiency

After reviewing the reading assignment on graphs and following the pseudo code. This breadth first traversal has a time complexity of O(N^2). We have a while loop, this loops through N times based on the number of nodes in our graph. Then for each node, we will for loop each relationship that node might have, which is N edges. We are using a holder set, to keep track of the visited nodes and at the very end we return a collection of the nodes, O(n) in space.

---

## Solution
![White Board Image](../../../assets/breadth_first/breadth_first.png)


text:
Parca is a continuous profiling project for applications and infrastructure.
It helps you save money, improve performance and understand incidents better.

Continuous profiling is the act of taking profiles (such as CPU, Memory, I/O and more) of programs in a systematic way.
Parca collects, stores and makes profiles available to be queried over time.
It features a powerful multi-dimensional data model, storage and query engine specifically designed for profiling data.

To find out more visit our [website](https://www.parca.dev/docs/overview)!

Now let's jump into action 🚀🚀🚀

repository: parca-dev/katacoda-scenarios

gha_language: Ruby

repo_name: parca-dev/katacoda-scenarios


text:
# Fuseki CLI [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

Fuseki is a populair SPARQL / Triplestore implementation in Java that is simple and robust to use. See [Jena Apache Jena Fuseki documentation](https://jena.apache.org/documentation/fuseki2/index.html) for more info. The Fuseki CLI is a build as a __TypeScript__ based _wrapper_ to use and support the services that are provided from the Open Source version.

## Jena Fuseki Server Dependencies

This pre-release only supports a local Jena Fuseki Service as a peer depedency for this package. See for info how to install and use: [@dgwnu/fuseki-service](https://github.com/dgwnu/fuseki-service).
_Other server installations could work but are not tested (or in scope). Hint: Any localhost installation should work like HomeBrew but there might be some authorization issues to resolve in "shiro.ini"_

## NPM installation

````
npm install https://github.com/dgwnu/fuseki-cli.git --save
````

## CLI-commands

At this moment there is only some prelimannary support to configure and use Fuseki-services Api.

### Services

````
npx fuseki < ping | server >
````

| Command | Function |
|---------|:------------|
| ping | Fuseki Server is Up or Down status check |
| server | Fuseki Server Configuration |

### Datasets

````
npx fuseki datasets <parameters>
````

| Parameters | Function |
|:------------|:------------|
| (<_datasetName_>) | Gets configuration of all datasets (or one specified by <_datasetName_>) |
| _-a_ (or _-add_) <_assemblerFilePath_> | Add dataset with <_assemblerFilePath_> configuration |
| _-r_ (or _-remove_) <_datasetName_> | Remove dataset specified by <_datasetName_>

### GraphStore Data Management
````
npx fuseki < put | post > <datasetName> <uploadFilePath>
````
Parameters must always be specified:
- <__datasetName__> the dataset to update
- <__uploadFilePath__> the location of data file to upload

| Command | Function |
|---------|:------------|
| put | Replace all with new data |
| post | Update (non-blank) nodes with new data (and add non-exsiting) |
_Other commands with other Service functionality will be added soon (in 2021 ;-))._

## CLI-library

This package provides a __TypeScript__ based library to reuse and /or extend the CLI-functionality.

Import library in your TypeScript-application and use it to make extended functionality:

````ts
import { ping } from '@dgwnu/fuseki-cli';

// Use Fuseki Server Ping Service
ping.subscribe({
    next: (up) => console.log(up),
    error: (down) => console.log(down)
});

````

The [Fuseki CLI source](src/bin/fuseki-cli.ts) provides all examples you need.

repository: dgwnu/fuseki-cli

repo_name: dgwnu/fuseki-cli


text:
# Solution to last week’s Riddler Classic

Congratulations to 👏 Reuven 👏 of Ottawa, Ontario, Canada, winner of last week’s Riddler Classic.

Last week, the mysterious Barbara Yew offered a mysterious number puzzle, where you had to find eight three-digit numbers. The products of the three digits of each number were shown in the rightmost column of the table below. Meanwhile, the products of the digits in the hundreds, tens and ones places, respectively, were shown in the bottom row.

![classic](RIDDLER.011521.webp "Table for eight three-digit numbers.")

The products of the three digits in each number are, respectively, 294, 216, 135, 98, 112, 84, 245 and 40. The product of the hundreds digits is 8,890,560. The product of the tens digit is 156,800. The product of the ones digit is 55,566.

First off, I’m delighted to report that this riddle was part of the annual (and this year, virtual!) [MIT Mystery Hunt](https://www.mit.edu/~puzzle/nexthunt.html), puzzles from which have [previously appeared](https://fivethirtyeight.com/features/can-you-stay-awake-for-50-hours-and-solve-150-puzzles/) in this column. The puzzle’s submitter, “Barbara Yew,” was a fictional character within the hunt, which was created and organized by last year’s winning team, the ✈✈✈ Galactic Trendsetters ✈✈✈. Indeed, this week’s winner, Reuven, participated in the hunt as part of team Control Group.

Your first step was to list out the different ways to multiply three digits from 1 to 9 to achieve each row’s product:

    294 was 6×7×7.
    216 was 3×8×9, 4×6×9 or 6×6×6.
    135 was 3×5×9.
    98 was 2×7×7.
    112 was 2×7×8 or 4×4×7.
    84 was 2×6×7 or 3×4×7.
    245 was 5×7×7.
    40 was 1×5×8 or 2×4×5.

For a few solvers, that last row — 40 — was tricky.

From here, there were a total of 2,729,376 unique ways to place these digits in the table. That wasn’t a prohibitively large number, and so some solvers, like Siddhartha Srivastava of Patna, India, powered forth with computational brute force to find the unique solution. But this puzzle was indeed solvable with pen (okay, pencil), paper and logic.

Your next step was to find the prime factorization of the products of each column:

    8,890,560 was 2^6×3^4×5^1×7^3.
    156,800 was 2^7×5^2×7^2.
    55,566 was 2^1×3^4×7^3.

Solver Sara McArdle took a closer look at the first column, whose prime factorization implied that four of the eight digits had to be 5, 7, 7 and 7. That meant the remaining factorization, 26×34, or 5,184, had to be the product of the remaining four digits. There was only one way to break down 5,184 in this way: 8, 8, 9 and 9. The two factors of 9 had to come from the second (216) and third (135) rows. Also, because the third column did not have a factor of 5, that meant the three-digit number in the third row had to be 953.

Because all of the first column’s factors of 3 were accounted for, that meant the first row’s 6 couldn’t be in the first column. Also, the second column did not include a factor of 3, which meant the last column had the 6. In other words, the three-digit number in the first row was 776.

That 6 from the first row was responsible for the third column’s single factor of 2. Since the first digit of the second row was 9, the only way that row’s third digit could be odd was for the three-digit number in the second row to be 983.

But what about those two 8s in the first column? At this point, they had to be in the fifth and eighth rows. Because the last column had no factors of 5, the three-digit number in the eighth row had to be 851. And because the third column wasn’t allowed any more factors of 2, the three-digit number in the fifth row had to be 827.

The first column still needs a factor of 5, and the only remaining place it can get it is from the seventh row, whose three-digit number had to be 577. Meanwhile, the first column had all its factors of 2 accounted for, so the three-digit number of the fourth row had to be 727. Last but not least, the three-digit number of the sixth row was 743.

When all was said and done, here was the completed table:

![classic](solution.webp "Table for eight three-digit numbers. The products of the three digits in each number are, respectively, 294, 216, 135, 98, 112, 84, 245 and 40. The product of the hundreds digits is 8,890,560. The product of the tens digit is 156,800. The product of the ones digit is 55,566. The eight numbers turned out to be: 776, 983, 953, 727, 827, 743, 577 and 851.")

Finally, a big congratulations to the winning team of this year’s incredible MIT Mystery Hunt, Palindrome!


text:
---
title: "Java Keystores"
linkTitle: "Java Keystores"
weight: 70
date: 2021-07-27
tags:
  - keystore
  - truststore
  - java
description: >
  How to create java key/trust stores for use with Java client applications.
---

There are many times when you may wish to create a Java keystore from certificates and keys and vice versa. This guide aims to explain how this can be done.

## Import
If you need to create a Java keystore from a .crt and .key then this is how to do it.

### Convert your keys to der format

```bash
openssl x509 -in <YOUR KEY>.crt -inform PEM -out <YOUR KEY>.crt.der -outform DER
openssl pkcs8 -topk8 -nocrypt -in <YOUR KEY>.key -inform PEM -out <YOUR KEY>.key.der -outform DER
```

### ImportKey
Use the `ImportKey` class in the `stroom-java-client` library to import keys.

For example:

```bash
java ImportKey keystore=<YOUR KEY>.jks keypass=<YOUR PASSWORD> alias=<YOUR KEY> keyfile=<YOUR KEY>.key.der certfile=<YOUR KEY>.crt.der
keytool -import -noprompt -alias CA -file <CA CERT>.crt -keystore ca.jks -storepass ca
```

## Export
### ExportKey
Use the `ExportKey` class in the `stroom-java-client` library to export keys. If you would like to use curl or similar application but only have keys contained within a Java keystore then they can be exported.

For example:

```bash
java ExportKey keystore=<YOUR KEY>.jks keypass=<YOUR PASSWORD> alias=<YOUR KEY>
```

This will print both the key and certificate to standard out. This can then be copied into a PEM file for use with cURL or other similar application.


text:
## Dobest PHP framework

## Contributing
Thank you for considering contributing to the Dobest framework!
### License
The Dobest framework is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)

repository: lkwfive/dobest

gha_language: PHP

repo_name: lkwfive/dobest


text:
Spring / Angular Bootstrap
=========

Provide a starting point for Spring / Angular applications with some goodies:
 - Gradle
 - Spring Boot
 - Spring Web
 - Spring Security
 - Spring Actuator
 - Spring Loaded
 - Hystrix
 - Swagger
 - Lizenzliste
    - https://github.com/jk1/Gradle-License-Report
    - https://github.com/eskatos/creadur-rat-gradle
    - https://github.com/giancosta86/MoonLicense-Gradle
 - [Asciidoctor](https://github.com/asciidoctor/asciidoctor-gradle-plugin)
 - JUnit 5
 - Gatling
 - (Groovy)
 - (Cucumber mit Groovy-Bindings)

TODOs
-----
 - Angular

repository: andreassimon/spring-angular-bootstrap

repo_name: andreassimon/spring-angular-bootstrap


text:
---
title: Bridge performance
summary: Performance considerations and scaling the bridge
reviewed: 2022-05-04
component: Bridge
---
This page describes performance considerations when using the `NServiceBus.Transport.Bridge` component and how to scale out. There are several reasons to scale out, such as to achieve higher message throughput, or to provide high availability.

## Performance tuning

The bridge moves messages using [the same default concurrency as NServiceBus endpoints](/nservicebus/operations/tuning.md#configuring-concurrency-limit) which is `max(Number of logical processors, 2)`.

Customize the concurrency level as follows:

snippet: custom-concurrency

## Scaling out

The performance of regular endpoints is impacted by many factors, including databases containing business data, or third party services like an SMTP server or a web service. In contrast, the performance of the bridge is affected mainly by resources like CPU, network and disk. This makes it an easier decision to scale out the bridge.

### Competing consumers

As with [regular NServiceBus endpoints](/nservicebus/architecture/scaling.md#scaling-out-to-multiple-nodes-competing-consumers), the easiest way to scale out is with [brokered transports](/transports/types.md#broker-transports), as those can make use of the *[competing consumer pattern](https://www.enterpriseintegrationpatterns.com/patterns/messaging/CompetingConsumers.html)*. This is done by deploying multiple instances of the bridge, all with the same configuration. Every instance will start processing messages from the same queue. When a message must be processed by the bridge, any of the instances could potentially process it.

The bridge accesses messages using NServiceBus transport packages. Each transport on its own will try to ensure that only one instance will actually process the message.

NOTE: MSMQ is not a brokered transport and cannot benefit from the competing consumer pattern.

### Splitting up the bridge

It is possible to use different logical instances of the bridge. Each logical instance can be configured so that it mimics only certain endpoints. In the diagram below, one bridge only takes care of Endpoint B and Endpoint C, while the other takes care of Endpoint A and Endpoint D. The result (which is not visible in the diagram) is that Endpoint B can still send messages to Endpoint D, but those will be processed by Bridge 2. When Endpoint A sends a message to Endpoint C, those messages will be processed by Bridge 1.

This can be useful when resources such as a CPU or disk are fully utilized and the competing consumers pattern isn't the appropriate solution.

NOTE: It may be practical to split up logical endpoints to increase throughput for *specific messages*. For the bridge this benefit is lost, as each endpoint that is mimicked by the bridge has its own message processing pipeline, separate from other mimicked endpoints.

```mermaid
graph LR
  Br2[Bridge 2<br /><sup>Endpoint A<br />Endpoint D</sup>]
  A[Endpoint A] --- Br2
  B[Endpoint B]
  Br2 --- D[Endpoint D]
  Br1[Bridge 1<br /><sup>Endpoint B<br />Endpoint C</sup>] --- C[Endpoint C]
  B --- Br1
  subgraph msmq
    A
    B
  end
  subgraph sql
    C
    D
  end
```

gha_license_id: NOASSERTION


text:
# A Biased Graph Neural Network Sampler with Near-Optimal Regret

```
@incollection{banditgnn_neurips21,
author = {Zhang, Qingru and Wipf, David and Gan, Quan and Song, Le},
title = {A Biased Graph Neural Network Sampler with Near-Optimal Regret},
booktitle = {Advances in Neural Information Processing Systems (NeurIPS) 34},
pages = {8833--8844},
year = {2021},
publisher = {Curran Associates, Inc.}
}
```

links
- [neurips](https://papers.nips.cc//paper/2021/hash/4a08142c38dbe374195d41c04562d9f8-Abstract.html)
- [virtual](https://neurips.cc/virtual/2021/poster/28383)
- [openreview](https://openreview.net/forum?id=qpdc7sCpbi)

gha_language: Jupyter Notebook


text:
# virtualfish-project

Extends [virtualfish][1] with the project folder functionality available in
[virtualenvwrapper][2].

This allows you to have a default `home` in a virtualenv. And it is compatible
with environments created with [virtualenvwrapper][2] (by using the .project
file)

## Installation

1. Clone this repository, or download the virtual-project.fish file somewhere.
   My personal preference is to clone it in the `.config/fish/` folder.

   ```Shell
   $ cd .config/fish
   $ git clone https://github.com/graffic/virtualfish-project.git
   ```

2. Import it in your config file **before** the `virtualfish` include.

   ```Shell
   set -x VIRTUALFISH_HOME ~/PythonEnvs/
   . ~/.config/fish/virtualfish-project/virtual-project.fish
   . ~/.config/fish/virtualfish/virtual.fish
   ```

## Usage

By *default* if a project directory is set for a virtualenv, after activation
your directory will change to that project directory.

If you haven't set a project directory for your virtualenv

1. Activate the virtualenv you want to configure
2. Change directory to the desired `project directory`.
3. Run:

   ```Shell
   $ vf setp
   ```

After a `project directory` is set in a virtual env, you can quickly jump to
it running:

```Shell
$ vf cdp
```

[![githalytics.com alpha](https://cruel-carlota.pagodabox.com/e00358c0d50e8daf5ed8f15ad3a59b3a "githalytics.com")](http://githalytics.com/graffic/virtualfish-project)

[1]: https://github.com/adambrenecki/virtualfish
[2]: http://virtualenvwrapper.readthedocs.org/en/latest/

repository: graffic/virtualfish-project

extension: markdown

repo_name: graffic/virtualfish-project


text:
---
layout: post
title: "Question-Answer Selection in User to User Marketplace Conversations"
date: 2018-02-06 02:39:54
categories: arXiv_CL
tags: arXiv_CL Attention RNN
author: Girish Kumar, Matthew Henderson, Shannon Chan, Hoang Nguyen, Lucas Ngoo
mathjax: true
---

* content
{:toc}

##### Abstract
Sellers in user to user marketplaces can be inundated with questions from potential buyers. Answers are often already available in the product description. We collected a dataset of around 590K such questions and answers from conversations in an online marketplace. We propose a question answering system that selects a sentence from the product description using a neural-network ranking model. We explore multiple encoding strategies, with recurrent neural networks and feed-forward attention layers yielding good results. This paper presents a demo to interactively pose buyer questions and visualize the ranking scores of product description sentences from live online listings.

##### Abstract (translated by Google)
用户到用户市场的卖家可能被潜在买家的问题淹没。产品说明中常常提供答案。我们收集了一个约590K的数据集，这些问题和答案来自在线市场的对话。我们提出了一个问题回答系统，使用神经网络排名模型从产品描述中选择一个句子。我们探索多种编码策略，用递归神经网络和前馈关注层产生良好的结果。本文提供了一个演示，交互式地提出买方问题，并可视化实时在线列表中的产品描述句子的排名分数。

##### URL
[http://arxiv.org/abs/1802.01766](http://arxiv.org/abs/1802.01766)

##### PDF
[http://arxiv.org/pdf/1802.01766](http://arxiv.org/pdf/1802.01766)


text:
Metior
======

Metior is a source code history analyzer API that provides various statistics
about a source code repository and its change over time.

Currently Metior provides basic support for Git repositories.

If you're interested in Metior, feel free to join the discussion on Convore in
[Metior's group](https://convore.com/metior).

## Examples

### One-liner for some basic statistics

    Metior.simple_stats :git, '~/open-source/metior'

### More fine-grained access to repository statistics

    repo = Metior::Git::Repository '~/open-source/metior'
    repo.commits 'development'         # Get all commits in development
    repo.significant_authors           # Get up to 3 of the most important
                                       # authors
    repo.significant_commits, 20       # Get up to 20 of the commits changing
                                       # the most lines
    repo.top_authors 'master', 5       # Get the top 5 authors in master

### Get statistics about a set of commits

    Metior::Commit.activity repo.commits
    Metior::Commit.activity repo.authors[author_id].commits

## Requirements

* Grit — a Ruby API for Git
  * [Git](http://git-scm.com) >= 1.6
* Octokit — a Ruby wrapper for the GitHub API
  * JSON — a JSON parser for Ruby

## Documentation

The documentation of the Ruby API can be seen at [RubyDoc.info][1]. The API
documentation of the current development version is also available [there][5].

## Future plans

* More statistics and analyses
* More supported VCSs, like Subversion or Mercurial
* Support for creating graphs
* Console and web application to accompany this API
* Code analysis to show programming languages, effective lines of code, etc.

## Contribute

Metior is a open-source project. Therefore you are free to help improving it.
There are several ways of contributing to Metior's development:

* Build apps using it and spread the word.
* Report problems and request features using the [issue tracker][2].
* Write patches yourself to fix bugs and implement new functionality.
* Create a Metior fork on [GitHub][1] and start hacking. Extra points for using
  Metior pull requests and feature branches.

## About the name

The latin word "metior" means "I measure". That's just what Metior does –
measuring source code histories.

## License

This code is free software; you can redistribute it and/or modify it under the
terms of the new BSD License. A copy of this license can be found in the
LICENSE file.

## Credits

* Sebastian Staudt – koraktor(at)gmail.com

## See Also

* [API documentation][1]
* [Metior's homepage][2]
* [GitHub project page][3]
* [GitHub issue tracker][4]

Follow Metior on Twitter [@metiorstats](http://twitter.com/metiorstats).

 [1]: http://rubydoc.info/gems/metior/frames
 [2]: http://koraktor.de/metior
 [3]: http://github.com/koraktor/metior
 [4]: http://github.com/koraktor/metior/issues
 [5]: http://rubydoc.info/github/koraktor/metior/master/frames

repository: LittleForker/metior

repo_name: LittleForker/metior


text:
# Akka Cluster Playground
Tinkering with Akka Cluster

This is a toy application developed to play a bit with Akka Cluster.
It is based on the [sample repo](https://github.com/akka/akka-sample-cluster-docker-compose-scala) provided by Akka, and on the [official documentation](https://doc.akka.io/docs/akka/2.5/cluster-usage.html). Do you want to play with it? Feel free to contribute! :smile:

## Running
The project is "docker-first", so we need to create the docker images to run using [sbt Native Packager](https://www.scala-sbt.org/sbt-native-packager/). Run the command `sbt docker:publishLocal`, it will create the image `elleflorio/akka-cluster-playground`.

Once you have the image, type `docker-compose up`. Docker compose will run a `seed` node along with `node1` and `node2`.

## API
I integrated [Akka HTTP](https://doc.akka.io/docs/akka-http/current/), so you can interact with the cluster using the following REST API.
The port for the nodes are the following:
* seed: `8000`
* node1: `8001`
* node2: `8002`

### Health
Check if the nodes are up and running calling a `/health` endpoint:
```
GET http://localhost:{{port}}/health
```
Response:
```
OK
```

### Members
Check the members inside the cluster using the `/status/members` endpoint:
```
GET http://localhost:{{port}}/status/members
```
Response:
```
[
    "akka.tcp://cluster-playground@node1:1600",
    "akka.tcp://cluster-playground@node2:1600",
    "akka.tcp://cluster-playground@seed:2552"
]
```

### Fibonacci
Ask for the computation of Fibonacci number `n` with the `/process/fibonacci/n` endpoint:
```
GET http://localhost:{{port}}/process/fibonacci/10
```
Response:
```
{
    "nodeId": "seed",
    "result": 55
}
```
The `nodeId` represents the node where the processor
that executed the computation is running.

## Cluster Aware Routers
The cluster uses [Cluster Aware Routers](https://doc.akka.io/docs/akka/2.5/cluster-routing.html) for load balancing, with a round-robin strategy. You can verify this asking for the Fibonacci number computation to a random node. Everytime the `nodeId` in the response will be different, following a round-robin strategy.

That's it! Enjoy! :grin:

repository: dungvo/akka-cluster-playground

repo_name: dungvo/akka-cluster-playground


text:
## Era PosgreSQL Database Provisioning
This Calm blueprint deploys a production grade PostgreSQL database by calling Nutanix Era APIs. With the 2018-02-10 update, a minimum of Era Version 1.0.1 is required.

To use this blueprint, import into a Prism Central running >= Calm <IP_ADDRESS>, and fill in the Credentials and Variables mentioned below.

##### Credentials
* era_creds: the admin account credentials for your Era Server
* db_server_creds: a private key that will allow SSH access to the Era provisioned Database

##### Variables
* era_ip: The IP address of your Era Server
* software_profile: The desired Software Profile of your Postgres DB Server
* compute_profile: The desired Compute Profile of your Postgres DB Server
* network_profile: The desired Network Profile of your Postgres DB Server
* database_parameter: The desired Database Parameters of your Postgres DB
* sla_name: The desired Time Machine SLA of your Posgres DB
* db_name: The name of database (be sure to keep this value unique within Era)
* db_password: The password for the "postgres" user of the database
* db_public_key: In conjunction with the "db_server_creds", this allows SSH access to the Postgres DB Server

repository: nutanix/blueprints

gha_language: Python

repo_name: nutanix/blueprints


text:
---
layout: post
title: 'Review: Antec P182 with Seasonic S12'
tags: [hardware,review]
redirect_from: /blog/archive/2008/03/16/review-antec-p182-with-seasonic-s12
---

A while ago, I decided to buy a new computer. I had three main
requirements:\

-   It had to be faster than my previous computer. As the old one was
    more than three years old, this requirement would not be hard to
    fulfil :-).
-   It had to be quiet. Very important!
-   It had to be reasonably power efficient. I try to keep my energy
    consumption down. \

I've tested various ways of getting a quiet computer over the years, the
most famous one being the beautiful red box described
[here](/writings/quietbox/ "My sound-absorbing computer box"). This
time, I did however go for a more standard solution that involved less
red paint..

### Hardware

After some research on quiet computer cases and power supplies, I
ordered the following stuff.\

Case

Antec P182 \

Power supply \

Seasonic S12-II, 380W \

Motherboard\

MSI K9AG Neo2 Digital\

Disks\

2x SAMSUNG HD321KJ in a Software RAID1 configuration\

CPU\

AMD Athlon X2 BE-2400 45W BOXED\

Memory\

2x 1GB DDR2 800MHz\

\

The Antec P182
--------------

The first thing I noticed about this case when I collected it at the
post office was that it is very heavy. Another thing I noticed when
taking it out of its cardboard box was that when you knock on one of the
sides of it, there's much less sound than when knocking on the side of a
standard case. This comes from the fact that the sides are covered in
plastic instead of being just steel, and I think it contributes much to
keeping the computer quiet, as vibrations are less likely to travel
through the sides of the case. \

### Opening up the case

![Antec P182 left
side](/images/django2jekyll/migrated/blog-archive-2008-03-images-antecseasonic-IMG_1735_explained.JPG-image_preview)Opening
up the case, a rather interesting construction is revealed. In the
picture to the left, I've removed the lower drive bay, which normally
sits in the area marked **A**. The power supply is mounted in the area
marked **B**.

What is very interesting is that Antec has chosen to divide the flow of
air into two distinct flow paths. There is the lower airpath where air
flows from the front, through an air filter that can be easily removed
for cleaning, then through the lower drive bay, via a 12cm fan that can
be individually controlled via a speed controller attached to a small
cable, and then finally through the power supply.

Then there's the upper airpath where air flows from the front, through a
second washable air filter, into the upper part of the box exiting
through one of two 12cm individually controllable 12cm fans. The two top
fans are controlled by external fan switches at the back of the case,
which allows adjustments of speed without opening the case. For my
configuration, I run the back fan at its lowest speed. I have not
connected the top fan at all.

Separating the air that flows through the power supply from the air in
the rest of the box ensures that the power supply's fan doesn't have to
run at top speed to move air that is hot because the processor or
graphics card is producing heat. This is a problem seen in many other
cases - even when there's a quiet 12cm fan in the case that can move the
hot air out of the box, the power supply fan runs at high speed because
its heat sensor feels the hot air that passes through the PSU and acts
accordingly, causing unnecessary noise. With the P182's solution, this
doesn't happen - the power supply's heat sensor only detects the heat
generated by the harddrives and the power supply itself.

The area marked with C is a special plastic slider that ensures that as
little air as possible travels between the upper and the lower air
paths, while still allowing cables to be run from the power supply up to
the motherboard and other parts requiring power, and also down to the
lower drive bay to power the hard drives.

### The right side of the case

![Antec P182 right
side](/images/django2jekyll/migrated/blog-archive-2008-03-images-antecseasonic-IMG_1736_crop.JPG-image_preview)On
the other side of the case, we see another neat feature - cable ties to
keep cables running from the power supply to the motherboard secured.

### Attention to detail

![Antec P182, lower drive
bay](/images/django2jekyll/migrated/blog-archive-2008-images-antecseasonic-IMG_1744.JPG-image_mini)There's
a lot of smart solutions in this box. Here's one example - the ring used
to pull out the lower and upper drive bays have a small plastic snap
that keeps it down when not used - avoiding any chance of it vibrating
causing noise!

### Conclusion

Overall, I'm extremely happy with this case. It's high quality, and it's
very very quiet! If you're willing to pay for quality, I definitely
recommend this case.\

Seasonic S12-II
---------------

The Antec P182 is sold without power supply unit (PSU). That gives the
owner flexibility in finding a PSU that fits with the requirements.\
\
![Seasonic
S12](/images/django2jekyll/migrated/blog-archive-2008-03-images-antecseasonic-IMG_1740_crop.JPG-image_preview)For
my new computer, I choose a 380W Seasonic S12-II based on
recommendations in a local forum. There are many power supplies
specifying that the fan is temperature controlled, but in reality, many
PSUs have really crappy fan controllers that keep the fan at higher
speed than necessary, causing noise. \
\
Like the Antec P182, the S12 has an aura of quality. It has a nice black
finish, and the outgoing cables are neatly organized. \
\
The PSU claims that it is very power efficient, which means that a lot
of the energy going into the PSU actually comes out. This is not the
case with cheap PSU's, where a lot of energy is wasted in the conversion
from high voltage AC to 12 and 5V DC. The energy wasted generates heat,
which has to be ventilated. So, an efficient PSU not only saves your
electric bill, it also makes your computer more quiet! ![Seasonic S12,
smart
connector](/images/django2jekyll/migrated/blog-archive-2008-03-images-antecseasonic-IMG_1743.JPG-image_preview)\
Here's a really nice feature - the 12V standard connectors for
connecting for example old harddrives, DVD readers, etc, are of a
special make that are much easier to disconnect.

### Conclusion

Seasonic S12-II is a PSU I can recommend.


text:
Visual Image Search and Annotation (VISA)
=========================================

VISA is a .Net library and application that allows searching a database of images based on their contents and auto-annotate them.

 - Provide a way of searching an image library based on the content of a query image provided by the user.
 - Auto-annotate all the images in a library.

Content Based Image Search in VISA
----------------------------------

VISA index images based on two features: region based color histogram and SURF feature.

 - Region Based Color Histogram: We split the image into 4 region and a center region for total 5. For each region we compute a 64 bins histogram for each of the bands and concatenate all of them to form a single vector. The resulted vector is the global feature descriptor.
 - SURF: We use standard OpenCV SURF as texture feature descriptors.

You can select to use both of the above feature for indexing or one of them only. The region based color histogram scale to millions of images, and the SURF can scale to thousand of images.

Auto-Annotation
---------------

For auto-annotation, we used 3 different algorithms depend on the category of the annotation. Most of the training were done in MatLab, and the resulted model were used in OpenCV. TBD: Add details and references.

Dependencies
------------
VISA depends on Emgu Library for all its OpenCV need, you can get the latest Emgu library from: http://www.emgu.com/

repository: battyone/visa

repo_name: battyone/visa


text:
# Usage
Here we describe how to use `certctl` for various operations. For Vault
specific documentation please have a look at https://www.vaultproject.io/docs.

At first you want to prepare your environment to provide the Vault address and
the Vault token to `certctl`. You can also provide these settings using the
command line flags, but then your commands are getting more messed up. Note
that you need to set a token having root access for the upcoming cluster setup.
```
export VAULT_ADDR=<vault-addr>
export VAULT_TOKEN=<vault-root-token>
```

When you want to know the state of a cluster, use the `inspect` command. Here
we see there had no setup happen yet.
```
$ certctl inspect --cluster-id=123
Inspecting cluster for ID '123':

    PKI backend mounted: false
    Root CA generated:   false
    PKI policy created:  false

Tokens may have been generated for this cluster. Created tokens
cannot be shown as they are secret. Information about these
secrets needs to be looked up directly from the location of the
cluster's installation.
```

Setting up a cluster works using the `setup` command. It is shown what happend.
`setup` can be called multiple times. A PKI backend is only mounted if it is
not mounted yet. A root CA is only generated if it is not generated yet. You
get the picture. One exception of this behaviour is the token generation. Each
call to `setup` generates `--num-tokens` tokens. So in case you need one more
token it is safe to simply call `setup` again for a specific cluster ID. Note
that we set a Vault token with root capabilities for the cluster setup.
```
$ certctl setup --allowed-domains=giantswarm.io --common-name=giantswarm.io --cluster-id=123
Set up cluster for ID '123':

    - PKI backend mounted
    - Root CA generated
    - PKI policy created

The following tokens have been generated for this cluster:

    265c159b-0fee-4198-b6d5-b6416752be04

```

When we now call `inspect` again we see that the cluster is set up properly.
```
$ certctl inspect --cluster-id=123
Inspecting cluster for ID '123':

    PKI backend mounted: true
    Root CA generated:   true
    PKI policy created:  true

Tokens may have been generated for this cluster. Created tokens
cannot be shown as they are secret. Information about these
secrets needs to be looked up directly from the location of the
cluster's installation.
```

In case the cluster is set up, we can generate certificates for it using the
`issue` command. Note that `issue` should only be provided the restricted token
generated on `setup`. That way it is more safe to automate the certificate
generation. Any process can then issue certificates for the cluster it was set
up for, and not more.
```
export VAULT_TOKEN=<vault-cluster-token>
```

```
certctl issue --cluster-id=123 --common-name=admin.giantswarm.io --crt-file=./crt.pem --key-file=./key.pem --ca-file=./ca.pem
Public key written to './crt.pem'.
Private key written to './key.pem'.
Root CA written to './ca.pem'.
```

At some point a cluster may not be used anymore, or needs to be cleaned up for
some reason. Here we can use the `cleanup` command. Note that a root token is
again necessary to cleanup a cluster.
```
export VAULT_TOKEN=<vault-root-token>
```

```
$ certctl cleanup --cluster-id=123
Inspecting cluster for ID '123':

    - PKI backend unmounted
    - Root CA deleted
    - PKI role deleted
    - PKI policy deleted

Tokens may have been generated for this cluster. Created tokens
cannot be revoked here as they are secret. Tokens need to be
revoked manually. In case a cluster with the same ID will be
generated, tokens generated for this cluster will be able to
access this new cluster again. Information about these secrets
needs to be looked up directly from the location of the cluster's
installation.
```

When we now inspect the cluster again, we see that it is no longer set up.
```
$ certctl inspect --cluster-id=123
Inspecting cluster for ID '123':

    PKI backend mounted: false
    Root CA generated:   false
    PKI policy created:  false

Tokens may have been generated for this cluster. Created tokens
cannot be shown as they are secret. Information about these
secrets needs to be looked up directly from the location of the
cluster's installation.
```

repository: giantswarm/certctl

gha_language: Go

repo_name: giantswarm/certctl


text:
---
id: 640
title: Developer Events in January
date: 2018-07-14T16:03:05+00:00
author: james.crowley
layout: revision
guid: https://www.jamescrowley.net/2018/07/14/68-revision-v1/
permalink: /2018/07/14/68-revision-v1/
---
Just thought I’d post some information about upcoming developer events in January dotted around the UK! If you haven’t been to one before, why not give it a go?

    Ian Griffiths on C# 3.0
Thursday, 12 January 2006, 18:30 – 21:00 in London, UK (London .NET User Group)

      With the covers barely off on C# 2.0 we are planning on kicking off the new year with a talk from Ian Griffiths on C# 3.0 – especially LINQ. I will have a fuller session description soon, but in the meantime this is a date for your new diaries.

    The Developers Group Meeting
Tuesday, 17 January 2006, 12:30 – 18:00 in Hammersmith, London, UK (The Developers Group)

      With talks on Design Patterns in .NET 2.0, Software Engineering Tools and the Lone Developer, The Fastcode Project and Using Classes to Replace Datamodules for Database Applications in Delphi Win32.

    VBUG: VS 2005 Launch
Tuesday,17 January 2006,19:00 – 21:00 in Glasgow, Strathclyde, UK (VBUG)

      VS 2005 &.NET Framework 2.0 launch is the major event of 2005. Every kind of application development has been enhanced with must-have features. Every kind of development & every kind of developer has compelling reasons why this is a must-have upgrade. In this session we will try to cover several weeks of training in a couple of hours including Generic & Protected Class & SQL Server 2005 Express.

    VBUG: SQL Server 2005 Security
19-19 January 2005 in Newcastle, UK (VBUG)

      This will be invaluable to SQL Server Developers who have found the interaction with SQL Server security frustrating & for SQL Server Database Administrators who have battled with Developers over imposing a security regime. Microsoft have worked hard to find a way for both sides to meet & agree on a security model that gives flexibility to the Developer and Security to the administrator.

    The Mobile Workforce: An Overview
Wednesday, 25 January 2006, 14:00 – 17:00 in Leeds/Bradford, UK (Black Marble)

      We will be exploring how to benefit your mobile workforce through the latest advancements in Mobile technology, and how to successfully integrate a mobile solution into your current business strategy. Products covered include Mappoint 2004, Windows Mobile and the Server side for mobile products.

    VBUG: VS 2005 Overview
Wednesday, 25 January 2006, 18:30 – 21:00 in Shipley, West Yorks, , UK (VBUG)

      VS 2005 and .NET Framework 2.0 launch is the major event of the year. Every kind of application development has been enhanced with must-have features. Every kind of development and every kind of developer has compelling reasons why this is a must-have upgrade. In this session Phil Winstanley will try to cover several weeks of training in a couple of hours . . . If anyone can, Phils your man

    VBUG: Threading with Annie Matthewman
Wednesday, 25 January 2006, 18:30 – 21:00 in Almondsbury Bristol , UK (VBUG)

      This session examines scenarios where you might want to use multi-threading & the common traps developers fall into when first trying to use it. It will look at how the .NET Framework exposes threads with worked examples in VB.NET

    MSDN TechTalk: Introduction to WinFX
Thursday, 26 January 2006, 18:30 – 21:00 in Reading, UK (Microsoft UK Ltd)

      WinFX is the new programming model for the Microsoft platform, bringing the power of the Windows Presentation Foundation, the Windows Communication Foundation and the Windows Workflow Foundation to .NET 2.0. This session will provide you with an overview of these technologies so that you can start to develop applications that take advantage of their capabilities.

gha_language: SCSS