text:
---
title: Essential Investing and Finance for developers
date: "2020-04-20"
author: franleplant
description:
  "Whether you are working on a fin tech startup or you want to start investing or
  you simply are curious about the world of investing and finance this post will be for you.
  We will layout a roadmap to learn the basics and beyond that resembles the path I’ve taken myself."
tags:
  - investing
  - finance
  - ETF
  - financial instruments
  - options
  - futures
  - stocks
  - portfolio
  - wealth
  - fintech
---

## Intro

Whether you are working on a fin tech startup or you want to start investing or
you simply are curious about the world of investing and finance this post will be for you.
We will lay out a roadmap to learn the basics and beyond that resembles the path I’ve taken myself.

This roadmap will be structured as a series of books you can read to become
financially literate and start taking control of your investing decisions.

## Disclaimer

Of course this post does not constitute financial advice and
you should seek professional help before
doing any serious investing.

Unless the world ends tomorrow and most of the concepts behind money, wealth,
jobs and socio-economics
are completely changed then you will probably
need to take control of these aspects of your life eventually,
so let this serve as an introductory step towards a better life!

## Prerequisites

Since this post is targeted towards developers
I assume you have some basic understanding of math.
I will cover which parts of the suggested roadmap
require explicit knowledge of somewhat advance calculus
and statistics but I can already tell you that that content will be mostly optional,
but I do believe that at least understanding
the complexity behind all these financial instruments is important.

As always when learning something new, you should have patience, an open mind and thirst for knowledge.

Lets being!

## Step 1: [The Millionaire Next Door](https://amzn.to/34uubpM)

Suggested formats: Digital, Paper and great as audiobook

Although this book is not strictly about finance nor investing, it does cover an aspect of
how most of the rich people in USA build their wealth, maintain it and live with it.

I assume that you are interested at least partially in building
and maintaining wealth
for you and your family and that is why you want to learn to invest,
if you don’t then you can probably skip this step.

What I really like about this book is that it grounds down the expectation of how it actually
is being wealthy. We have a very weird and incorrect understanding of what being wealthy means
thanks to TV, Movies and now Social Media and, spoiler alert, most of the Millionaires in United States
are hard working men and women that live frugally, are great savers and live well below their means and
with the extra cash they can commit to long term conservative investments, generating
long term wealth.

So yes, being wealthy usually does not mean having tons of super expensive cars, good looking human partners,
sail boats in the Mediterranean, mansions and careless expending. These in fact are roads towards being
poor actually in most cases and are only part of the [Collective unconscious][1].

I recommend reading this book because it talks a lot about building wealth and saving, activities that
are super important as a foundational steps towards investing.

## Step 2: [A Random Walk Down Wall Street](https://amzn.to/2Xr4MMo)

Suggested formats: Digital, Paper and great as audiobook

This is a good and short book that covers a wide variety of financial instruments and
investment techniques and concludes that most of the time the typical retail investor (i.e. you and me) is
better off following a simple technique called: buy and hold of conservative instruments
such as equities, bonds and [ETFs][3].

It gives a good and quick rundown of important concepts such as [Value Investing][2],
[Fundamental Analysis][4], [Technical Analysis][5],
ETFs, Equities (stocks), government bonds, corporate bonds,
[Modern Portfolio Theory][9], [Behavioral economics](https://www.investopedia.com/terms/b/behavioraleconomics.asp)
etc.

So after reading this books you will have a proper
holistic knowledge of the investment world and perhaps it will serve you
to identify your own path down this rabbit hole.
Perhaps you become interested in Technical Analysis or
perhaps you want to know more about Value Investing like the legend Warren Buffet.

## Step 3: [The intelligent investor](https://amzn.to/2VeUOuE)

Suggested formats: Digital, Paper and great as audiobook

I got to this book because it is well recommended by a lot
of blogs and forums and it is actually recommended
by [Warren Buffet himself][6].

It is a rather long book that talks about in details
about the “Buy and Hold” investing strategy and
the benefits of it and how it fits perfectly the retail investor.
This book also introduces the concept
of [Dollar Cost Average][7], a technique that will
help you invest consistently while averaging the prices that
you pay for instruments, easing any low and high peaks
you might encounter in the road (the main benefit is easing the high
peaks of course).

## Step 4: [MIT’s Finance Theory I][11] and [Principles of Corporate Finance](https://amzn.to/2RumRW8)

Suggested formats: Paper and, as a second option, Digital

This is the step where you become a pro.

The good old MIT has the generosity of making publicly
available a lot of top notch courses, along with
their syllabus, exercises and any other associated material.
These constitute one of the best learning resources
that I’ve encounter in several areas of knowledge
like computer science, math and, what we are here today, finance.

In particular this course has three key aspects that make
it an invaluable learning resource in the path of
financial literacy:

- The content covers a wide variety of topics that together constitute the fundamental of the modern financial world.
- The instructor Andrew Lo does an amazing job covering the material and relating it to real world scenarios.
- The course is from the Fall of 2008, right in the middle of one of the worst US and world financial crisis in the last 100 years: the [2008 Great Financial Crisis][8]. And a lot of the material covered is directly related to what was happening then. In fact, there is a particularly good session where Andre Lo teaches about how a pool of investments can be structured and resold via the “Trench” technique. And the abuse and misuse of this techniques is one of the main culprits of the financial crisis.

We conclude then that this course is well timed, complete and overall amazing for all levels.

You might get lost here or there when they go to calculating the price of futures and options when they start
using second derivatives and infinite series expansions but with the proper patience you can come to either
understand it or simply mark it as “TODO” (developer slang for _that which remains to be done_).

Additionally this course follows very closely the material
covered in the book _"Principles of Corporate Finance"_
from _"Richard Brealey, Stewart Myers, Franklin Allen"_
which I believe is a great book overall.

You can easily opt for just one of these resources or
work them together since they complement each other so much.

These last two resources actually cover probably more than you want to know but they are a very good
resource if you really want to know some of the nitty-gritty details behind all this complex instruments.

A specially useful section is the one where they cover the [Modern Portfolio theory][9], after you learn this you will
understand one of the most important aspects of being a successfully investor:
[Diversification][10].

## A note on crypto

Some of the material here does translate to the crypto world. In fact, at the time of writing this article there are
tons of innovative projects trying to build a lot of the traditional financial instruments into crypto. In fact we already
have futures, options and some other instruments being either available or in development.

If you are working on a Fin Tech that works on top of the
Ethereum network you will probably already know most of these
things but otherwise you will probably want to at least understand the basics.

On the topic of Crypto I cannot recommend enough [The Bitcoin Standard](https://amzn.to/34w4AwF).
It runs down on the essence of money and how bitcoin fits in as a potentially revolutionary
store of value.

Suggested Formats: Digital, Paper and great as Audiobook

## Closing

I wrote this post because this is a question I actually get quite often and I decided to sit down and
write it so that I can reference to it later.

All these books have affected me profoundly and I cannot recommend them enough.
All the books linked have affiliate links that help support this blog.

[1]: https://en.wikipedia.org/wiki/Collective_unconscious
[2]: https://www.investopedia.com/terms/v/valueinvesting.asp
[3]: https://www.investopedia.com/terms/e/etf.asp
[4]: https://www.investopedia.com/terms/f/fundamentalanalysis.asp
[5]: https://www.investopedia.com/terms/t/technicalanalysis.asp
[6]: https://www.cnbc.com/2017/02/02/billionaire-warren-buffett-discusses-the-book-that-changed-his-life.html
[7]: https://www.investopedia.com/terms/d/dollarcostaveraging.asp
[8]: https://en.wikipedia.org/wiki/Financial_crisis_of_2007–08
[9]: https://www.investopedia.com/terms/m/modernportfoliotheory.asp
[10]: https://www.investopedia.com/terms/d/diversification.asp
[11]: https://www.youtube.com/playlist?list=PLUl4u3cNGP63B2lDhyKOsImI7FjCf6eDW

repository: franleplant/nosleepjavascript-blog

branch_name: refs/heads/develop

gha_language: TypeScript

repo_name: franleplant/nosleepjavascript-blog


text:
# What is Infinit?

Infinit’s storage platform transforms commodity servers into multiple flexible, scalable, secure and fault-tolerant storage logics tailored to your applications.

%%LOGO%%

# How to use this image?

The following commands show Docker-specific tips for a pleasant integration between Infinit and Docker. For the Infinit-specific documentation, consult [Infinit's website](https://infinit.sh/get-started).

## Basics

	docker run --rm infinit

### Sharing configuration folder

Infinit stores its configuration under `/root/.local/share/infinit`. If you want to share this folder with your host, you can mount your host's configuration folder as a volume in your container.

	docker run -v ~/.local/share/infinit:/root/.local/share/infinit --rm infinit

*N.B. This might affect permissions of the mounted folder.*

### Using your user

By default, Infinit uses the current user, `root` when running on a container. If you want to use your local user name, you can set the INFINIT_USER environment variable.

	docker run -e INFINIT_USER=$USER -v ~/.local/share/infinit:/root/.local/share/infinit --rm infinit

### Accessing storage logics

For now, the only logic available is a distributed file system.

#### File system

On UNIX-based systems, Infinit uses `FUSE` to provide mount points. Hence, for UNIX-based containers, you need `FUSE` installed on your host (see Infinit's [get-started page](https://infinit.sh/get-started#installation)) and run Docker with specific options (`--cap-add SYS_ADMIN --device /dev/fuse`).

	docker run --cap-add SYS_ADMIN --device /dev/fuse -e INFINIT_USER=$USER -v ~/.local/share/infinit:/root/.local/share/infinit --rm infinit volume mount --name <VOLUME> --mountpoint <DIRECTORY>

*NOTE: On Windows systems, Infinit uses `Dokan`, but Windows-native containers aren't officially supported yet by Infinit.*

More file system interfaces will be added in the future to acces file storage logics.

#### Others (object, block, etc.)

At current version (0.8.0), the single logic exposed is the distributed file system but more logics will be added in the upcoming releases, such as an object storage logic, a block device logic and various interfaces for them.

license: MIT

repository: Dimrok/docs

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Dimrok/docs


text:
# Structure of a document

The purpose of the system to capture not only the content of a document but also its structure.
The point of capturing the structure is that it contains information too, and when one have
multiple documents in the system based on structure information possible to make connections
between content and structure.

In order to be able to store content in useful fashion we need to know the structure of the
document we want to work with. When capturing the structure we use multiple and nested objects.

## Source

A Source describes from we get or request information. It can be and url or organization name,
like Gutenberg.org or any unique identifier.

## SourceFormat

SourceFormat object describes the document format belongs to a source. A Source can be an url,
for example a blog from where we query RSS feed, or content in defined format, for example
text files from [Gutenber](https://gutenberg.org).

## DimensionStructure and DimensionStructureNode

Understanding what is DimensionStructure one need to be aware of that in this system a
document is considered as tree structure. In this tree the nodes may or may not contain
information. These nodes are the DimensionStructure objects. However, in the implementation
the tree is built by DimensionStructureNode objects. The reason is that we need to separate
the information and functionality of a node. Information is the DimensionStructure, while
tree functionality is captured in DimensionStructureNode objects.

In case of text a DimensionStructure can be a paragraph, a sentence or a word. In case of HTML
document a DimensionStructure can be text wrapped in a HTML tag.

DimensionStructureNode describes the tree structure of DimensionStructures. They provide a wireframe
of the document and that objects, like DimensionStructure, can be added to nodes.

repository: Andras-Csanyi/DigitalLibrary

gha_language: C#

gha_license_id: MIT

repo_name: Andras-Csanyi/DigitalLibrary


text:
# Utils functions description

## Neighboring matrices
eeg_neighbmat and source_neighbmat functions compute the neighboring matrix in sensor and source domain respectively.

eeg_neighbmat takes as input a cfg parameter composed of elec, channel and template_chan fields defined as follow:
* elec: sensors description (cf. ft_read_sens)
* channel: n_chan_elec x 1 cell with the labels of the desired channels in elec
* template_chan: n_chan_artf x 1 cell with the labels of the template artifact signals (in benchmark data, artifact signals are given on a 19-channels set-up (Hamid et al., 2021))

Here is an example:
```
cfg = [];
cfg.elec = elec;
cfg.channel = labels;
cfg.template_chan = artf.label;
neighboring_artf = eeg_neighbmat(cfg);
```

source_neighbmat takes as input the atlas and a boolean defining whether or not the neighboring matrix should be displayed at the end.

Here is an example:
`neighboring_matrix = source_neighbmat(atlas,0);`

## Custom atlas
There are 2 possible ways to customize your atlas: modify an existing one through `select_roi` function or create a new one from an atlas in NIfTI format through `prepare_atlas` function as showed in the following examples
1. ```
	roi_mat = {[3,5];[4,6];[7,9];[8,10];[11,13,15];[12,14,16];61;62};
    [atlas] = select_roi(atlas,roi_mat);
    ```
2. ```
	atals_path ='FieldTrip\template\atlas\aal\ROI_MNI_V4.nii';
	rois = [1:90];
	atlas = prepare_atlas(atlas_path,rois)
	```
Note: you can combine both functions by passing `roi_mat` as third argument of the `prepare_atlas` function.

To realign the atlas to a specific head model, rename or delete `transform_sourcemodel_atlas.mat` from utils.

## Compute ROI-by-ROI source activity
To perform the evaluation through the proposed framework, you need to get the source activity as 1 signal per brain region. This is what the `dipole2roi` function does. Basically, this function takes the output of `ft_sourceanalysis` and the atlas as inputs to compute ROI-by-ROI source signal. Example:
```
...
source_dipole = ft_sourceanalysis(cfg, timelock);

source_roi = dipole2roi(source_dipole,atlas);
reconstr_source.signal = source_roi.pow';
reconstr_source.label = source_roi.label';
```
`reconstr_source` is the required structure to run the evaluation process.

repository: LucaLaFisca/ValidEEG

branch_name: refs/heads/main

repo_name: LucaLaFisca/ValidEEG


text:
---
 layout: post
 title: My 2023 Job Search
---

Unfortunately I was impacted by a layoff at my former company, [Snapdocs](https://www.snapdocs.com/), earlier this year. After taking a short break, I started a full throttle search for a new role. The job hunt definitely is difficult in this current atmoshpere. Given all the other layoffs and the dwindling openings available, I knew it was going to take time and determination. It was a full time job itself, working on networking, searching for jobs, applying for jobs (with customized resumes and cover letters), and preparing for interviews. The first couple interview cycles were a little rough with some rustiness on my part. But I started regaining that interviewing muscle memory and started not only getting more interview requests but getting further into the interview rounds.

Going into the job search, I was hoping to accept an exciting opportunity within six months. I knew that I my goal was not to just accept the first offer I got. I have some things I look for and certain non-negotiables. Consequently, I was unafraid to ultimately pass on a job offer if it did not look like it would be a great fit, for both sides. Its important to me that there is that good fit for both myself and future emmployer to ensure success for everyone. But I found an awesome role with [Sprout Social](https://sproutsocial.com/)! I consider myself very lucky to be able to get such an exciting role, very much breaking my initial six month expectation. In fact, from layoff to accepting the offer, it was only 84 days! I am very grateful to the numerous people who helped my directly and indirectly in this search.

## Details and Viz

Of course, like many other things in my life, I kept track of the job search and thus have a few visuals to share for this post. I have seen Sankey diagrams to show the job search outcomes and wanted to make one as well, which you can see below. A few things stick out, at least to me:

- The overall response rate to my 148 job applications was a little over 12%. At the beginning of the search, this percentage was much lower and steadily increased as time went on.
- Nearly half (45%) of my applications were rejected with an automated email and a slightly smaller percentage (42%) never responded at all.
- Of the 18 applications that I started an interview cycle, 5 ghosted me and I still have not heard from them. Still other companies also did not respond for weeks after the final round before sending an automated rejection email.

 {: .center}
![png]({{ site.baseurl }}/files/job-search2023/job_plot.png)

In addition to keeping track of application statuses and the like, I also kept track of all the actual job descriptions. For these, I wanted to create a word cloud (see it below). What are the common keywords across all the data science and machine learning roles that I had applied to? To do this, I applied a homebrew version of [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) to get the word counts before visualizing. I removed traditional stopwords and added several to that list after looking at the first output of the algorithm. The big factor in the additional stopwords were numbers (i.e. "5 years of experience"). After a few iterations, the final output is below:

 {: .center}
![png]({{ site.baseurl }}/files/job-search2023/wordcloud.png)

Its not as obvious what the top ten words are, but for easier reading, those are:
1. data
2. work
3. team
4. product
5. python
6. model
7. ability
8. business
9. machine learning
10. data science

It should be obvious that "data" would be the first and most popular term. What is more interesting to me is that "product" ranked higher than "python", "model", "data science", and "machine learning". In addition the term "business" also is in the top 8 beating out "machine learning" and "data science". This should not be too much of a surprise as a (non research) data scientist should be focused on business goals and objectives. After all, the point in a company is usually to solve business problems and not necessarily academic ones.

## Parting Thoughts

I wanted to make a quick post about my job search from this year. I collected and tracked a fair amount of data and it was fun to visualize it to better understand that journey. Please do not hesitate to reach out and contact me if you have any questions or if I can help in any way. Cheers!


text:
# ui-paginate

![uiPaginate](http://jasontavarez.com/x/uipagination.png)

Flexible pagination generation using pure javascript, no dependencies. Created to be as versatile as possible: you can let it create page links and split up element rows accordingly in your html, or use underlying data object to create your own interface and logic.

##### Caveats/Immediate goals
1. This is still an early release, so you may see certain quirks. Please submit feedback if you find anything!
2. Better documentation and examples are my priority
3. Logic is more or less all in place but certain variable names may change
3. Will add unit tests later on
4. Need to finalize testing across browsers. This has been working so far on all modern browsers and IE9+

### Usage

**Install**

Via NPM

1. `npm install ui-paginate`
2. `import uiPaginate from ‘uiPaginate’`

Via old-fashioned way

1. Download raw file in `dist` folder
2. Link to it in \<head> of document

**Initialize**

````
var pager = uiPaginate({
	items : ’tr.row’,
	paginateContainer : ‘#pagination’
})
````

Where items are the html elements you need grouped by page and paginateContainer is where the links will go. You can also pass in a number or array and work directly with the data object that is used to create the html elements (no DOM needed), and there are many more configuration options available (see below)

#### Instance Methods

**info()**

Call at any point to retrieve pertinent info on paginated items. You can use this to customize logic and interface if needed. Returns following object

````javascript
{
	// Currently selected page
 	current: 0

	// Index of the first and last items within the selected page
 	firstItemIndex: 0
	lastItemIndex: 9

 	isFirst: true
 	isLast: false
 	isNearStart: true
 	isNearEnd: false

	// Representing the previous and next pages
 	next: 1
 	prev: 0

	// General information
 	itemsPerPage: 10
  	totalItems: 300
 	totalPages: 30
}
````

In addition to the generated html links which handle user input, you can also programmatically set pages with the following methods.

**setPage(number)**

Sets current page to specified number. Remember that this is a zero-based index, similar to dealing with arrays.

**next(), prev()**

Increments and decrements the current page, respectively. The default value of 1 can be changed

**redo(config)**

Recreates pagination object, where any new configuration options are merged with existing options. You call this method anytime results or item count chnages and you need to 'recount' pages. In those cases you call this method with `items` property

#### Configuration options

What you see below are all the default options used to create uiPaginate instance, and can be changed when passing in config object

````javascript
var defaultOptions = {

	// Only required option, can be one of the following
    // 1) String representing selector : 'tr.row'
    // 2) Nodelist (can be jQuery!) : $('tr.row)
    // 3) Array, where length will be used
    // 4) Integer
    // Providing #3-4 assumes you will add extra logic for showing items
 	items : null,

	itemsPerPage : 10,
 	startingPage : 0,

    // Where pagination elements are appended to. Leaving as false
    // assumes you will implement your own pagination controls
    // (utilizing info() object). Expects a String selector
	paginateContainer : false,

    // Given to every pagination element
 	className : 'page-link',

    // Prepended before certain classes for more granular styling
    // (button, disabled, first, last)
    prefix : 'page-',
    // Labels for First and Last buttons, or set to false to hide

    skipLabels : ['First', 'Last'],
 	// Show '1' and last page '#' in addition to First and Last buttons
    skipLabelsInclusive : true,

    // Labels to show for Previous and Next increments, or false to hide
    incrementLabels : ['Prev', 'Next'],
	incrementCounter : 1,

    // Shown on either side of centerPages when needed. Can set to false to hide,
    // though that isn't recommended
	divider : "...",

    // Don't create pagination elements if its just one page. Set to true
    // if there's heavy user interaction (i.e., updating
    // page results with filter options)
	displaySinglePage : false,

    // Number of pages to show on each side. Can be also false or 0
    marginPages : 2,

    // Number of pages to show in middle
    centerPages : 5

    // Tag used to create elements. Can be 'div','span','a','li','th', or 'td'
    element : "span",

    // Hooks
  	// Function that will be called whenever page changes
    // Info parameter is passed containing new pagination info
    // (same as calling info() method)
	onPageSelected : (info){}
}
````

Examples coming soon! Feel free to submit issues or provide feedback.

repository: jtavarez/ui-paginate

repo_name: jtavarez/ui-paginate


text:
### climateExtract <img src="man/figures/logo.png" align="right" alt="" width="120" />

<!-- badges: start -->
[![Build Status](https://app.travis-ci.com/RetoSchmucki/climateExtract.svg?branch=master)](https://app.travis-ci.com/RetoSchmucki/climateExtract)
<!-- badges: end -->

### R functions to extract and manipulate ECAD climate data
* ECAD at [Copernicus Climate](https://surfobs.climate.copernicus.eu/dataaccess/access_eobs.php#datafiles)
* Package URL: [https://retoschmucki.github.io/climateExtract/](https://retoschmucki.github.io/climateExtract)

> Before extracting any data, please read carefully the description of the datasets and the different grid size available (eg. 0.25 deg. regular grid, "TG" average temperature).
> Note shorter time-series are also available [Copernicus Climate](https://surfobs.climate.copernicus.eu/dataaccess/access_eobs.php#datafiles)

#### News
* 30/04/2023 ("Witty-Rose")
  - Updated to E-OBS v27.0 (April 2023)
    1. extending data from January 1950 to December 2022

* 16/06/2022 ("Curious-Rose")
  - Updated to E-OBS v25.0 (June 2022)
    1. extending data from January 1950 to December 2021
    2. Fixed a bug in GDD producing NA when minimum and maximum temperatures were the same.

* 03/02/2022
  - Updated to E-OBS v24.0 (November 2021)
    1. extending data from January 1950 to June 2021

* 29/11/2021 ("Climbing-Rose")
  - added Growing Degree Day functions
    1. compute gdd with the average temperature method
    2. compute gdd using Baskerville-Emin method
    3. compute the cumulative sum over RasterBrick layers

* 14/07/2021
  - added functionality for three new variables
    1. daily averaged sea level pressure PP
    2. daily averaged relative humidity HU
    3. daily mean global radiation QQ

* 07/04/2021 ("Wild-Rose")
  - Updated to E-OBS v23.1 (March 2021)
  - Optimized several functions
  - Added option to write data to a raster brick
  - Better used of memory
  - Extract data within a bounding box of polygons or points
  - Option to manually select the E-OBS version

#### Installation

GitHub installation (CRAN not available)

```
install.packages("devtools")
devtools::install_github("RetoSchmucki/climateExtract")
```

Dependancies: `ncdf4`, `data.table`, `sf`, `stars`, `sp`, `raster`, `terra`, `zoo`, `methods`

#### Usage

Check default ECAD version (can be changed with `ecad_v = xx.x`)

```R
library(climateExtract)
ecad_version
```

Define specific regions and/or points. If not provided, data will be extracted from the entire ECAD extent.

```R
# use set.seed() for reproducibility
set.seed(42876)
fr_border = sf::st_as_sf(raster::getData("GADM", country = "FRA", level = 0))
sf_point = sf::st_sf(sf::st_sample(x = fr_border, size = 25, type = "random"))
```

Extract data
- Retrieve climate data from E-OBS server or a local file if available.
- Crop to the extent of the spatial object provided.
- Specify years and data of interest; see details help(extract_nc_value).
- Write output to local disk with `write_raster=TRUE`
- If `return_data = TRUE`, an R object (a list) with the climate values is created.

```R
climate_data = extract_nc_value(first_year = 2012,
                                last_year = 2015,
                                local_file = FALSE,
                                file_path = NULL,
                                sml_chunk = "2011-2022",
                                spatial_extent = fr_border,
                                clim_variable = "mean temp",
                                statistic = "mean",
                                grid_size = 0.25,
                                ecad_v = NULL,
                                write_raster = TRUE,
                                out = "raster_mean_temp.grd",
                                return_data = TRUE)
```

Connect to the raster brick created on the local disk. If too big to be stored in Memory, the raster package will set a pointer to the file.

```R
rbk = raster::brick("raster_mean_temp.grd")
format(object.size(climate_data), "MB")
format(object.size(rbk), "MB")
```

Aggregate the data over time, "annual", "monthly" or by using a rolling "window". The function `mean` could be replaced by `sum, `sd`, or other functions that can be computed along a vector. If "daily" is selected as time_step, no aggregation is conducted as ECAD data are provided on a daily scale.

```R
# monthly mean
monthly_avg_temp_R = temporal_aggregate(x = rbk,
                                        agg_function = "mean",
                                        variable_name = "average temp",
                                        time_step = "monthly")
# annual mean
annual_avg_temp_R = temporal_aggregate(x = rbk,
                                       agg_function = "mean",
                                       variable_name = "average temp",
                                       time_step = "annual")
# 7-day rolling mean
window_7d_avg_temp_R = temporal_aggregate(x = rbk,
                                          agg_function = "mean",
                                          variable_name = "average temp",
                                          time_step = "window",
                                          win_length = 7)
```

>Note: Argument in `x` could also be the climate_data object that resulted from the `extract_nc_value()` function.

Aggregation for points if a spatial point object is provided in `y` argument (e.g., `y =` sf_point`).

```R
# annual mean per point
annual_avg_temp_pnts = temporal_aggregate(x = rbk,
                                          y = sf_point,
                                          agg_function = "mean",
                                          variable_name = "average temp",
                                          time_step = "annual")
```
>Note: Here, `site_1` is located along the coast and falls outside the raster grid cell with a value, the value returned correspond to the nearest cell with a value. Distance_from_pnt indicates distance to cell centroid, when within a cell with value, this is NA.

Map of the aggregated layer. For a map of the average temperature for Sept 2012, use layer `"2012.09"`.

```R
raster::plot(monthly_avg_temp_R[["2012.09"]])
```

Add points to the map, here with a circle around point 1 to show a point near the coast of Corse (bottom right corner).

```R
raster::plot(monthly_avg_temp_R[["2012.09"]])
plot(sf_point, col = 'magenta', pch = 17, add = TRUE)
plot(sf_point[1,], col = 'blue', border= 1.5, cex= 2, pch = 1, add = TRUE)
```

#### GDD

Calculate growing degree day values using your preferred base temperature and method. There are a number of new functions for calculating GDD values and cumulative sum (accumulated) GDD over user-defined periods. First, you need to get the daily average temperature or the minimum and maximum if you want to use the Baskerville-Emin method (method = 'be'), which fits a sine curve to the minimum and maximum to account for daily temperature fluctuations.

```R
# get minimum temperature

climate_data_min = extract_nc_value(first_year = 2012,
                                    last_year = 2015,
                                    local_file = FALSE,
                                    file_path = NULL,
                                    sml_chunk = "2011-2022",
                                    spatial_extent = fr_border,
                                    clim_variable = "min temp",
                                    statistic = "mean",
                                    grid_size = 0.25,
                                    ecad_v = NULL,
                                    write_raster = TRUE,
                                    out = "raster_min_temp.grd",
                                    return_data = TRUE)

rbk_min = raster::brick("raster_min_temp.grd")

climate_data_max = extract_nc_value(first_year = 2012,
                                    last_year = 2015,
                                    local_file = FALSE,
                                    file_path = NULL,
                                    sml_chunk = "2011-2022",
                                    spatial_extent = fr_border,
                                    clim_variable = "max temp",
                                    statistic = "mean",
                                    grid_size = 0.25,
                                    ecad_v = NULL,
                                    write_raster = TRUE,
                                    out = "raster_max_temp.grd",
                                    return_data = TRUE)

rbk_max = raster::brick("raster_max_temp.grd")
```
Using the function `gdd_extract()` we can calculate the GDD, specifying the base temperature and the preferred method,
Baskerville-Emin method (method = 'be') or simply the average daily temperature (method = 'avg'). For the average method you can specify either the mean_temp or the min_temp and max_temp. For the 'be' method, both min_temp and max_temp are needed.

```R
be_gdd_france <- gdd_extract(base_temp = 7,
                            min_temp = rbk_min,
                            max_temp = rbk_max,
                            gdd_method = 'be')

# visualise the GDD-base7, for June 16th 2012
raster::plot(be_gdd_france[["X2012.06.16"]])
```

The output is a RasterBrick (multilayer raster) that you can use with the function `temporal_aggregate()` to calculate the sum, mean or rolling window mean. In general, however, we need the cumulative sum, i.e. the accumulation of GDD over a certain period of time. For this task, you can use the function `cumsum_rb()` (cumulative sum on RasterBrick). This function uses the GDD RasterBrick and a vector that indexes the layers within the Brick and defines the specific time period (e.g. monthly, yearly). These indices are derived with the function `get_layer_indice()` (see below). On the other hand, you can also specify your own index vector.

```R
tp_index <- get_layer_indice(x = be_gdd_france,
                             pattern = "X",
                             date_format = "%Y.%m.%d",
                             indice_level = "year")

year_cumsum_gdd_france <- cumsum_rb(be_gdd_france, indices = tp_index)

# visualise the GDD base7 accumulated between January 1st until June 16th 2012.
raster::plot(year_cumsum_gdd_france[["X2012.06.16"]])
```

To get the cumulative GDD at the end of each month, you can calculate the cumulative total monthly and then extract the last day of each month. The following script generates a RasterBrick of the total GDD accumulated at the end of each month.

```R
tp_index <- get_layer_indice(x = be_gdd_france,
                             pattern = "X",
                             date_format = "%Y.%m.%d",
                             indice_level = "month")

month_cumsum_gdd_france <- cumsum_rb(be_gdd_france, indices = tp_index)

# get the indices for the last day of each month
last_day_index <- as.numeric(table(as.numeric(factor(lubridate::floor_date(as.Date(gsub("X", "", names(month_cumsum_gdd_france)), "%Y.%m.%d"), "month")))))

month_cumsum_gdd_france[[cumsum(last_day_index)]]
```

#### Meta

* See citation and ECA&D/E-OBS data policy [https://surfobs.climate.copernicus.eu/dataaccess/access_eobs.php\#datafiles](https://surfobs.climate.copernicus.eu/dataaccess/access_eobs.php\#datafiles)
* Register as an E-OBS user at <https://surfobs.climate.copernicus.eu/dataaccess/registration.php>
* Package URL: [https://retoschmucki.github.io/climateExtract/](https://retoschmucki.github.io/climateExtract)
* Raise issues: [https://github.com/RetoSchmucki/climateExtract/issues](https://github.com/RetoSchmucki/climateExtract/issues)
* Get citation information for `climateExtract` in R doing `citation(package = 'climateExtract')`

* Suggested citation:
  * Schmucki R. (2022) climateExtract: Extract and manipulate daily gridded observational dataset of European climate (E-OBS) provided by ECA&D. R package version 1.25. https://github.com/RetoSchmucki/climateExtract

repository: RetoSchmucki/climateExtract

gha_language: R

repo_name: RetoSchmucki/climateExtract


text:
## Oracle OpenWorld Ziplabs ##

* [Access an Oracle Cloud Platform Trial Account](2019/new-account)
* [Provisioning Autonomous Data Warehouse](2019/adw-provisioning)
* [Loading Data into the Autonomous Database](2019/adw-loading)
* [Getting Started With Oracle Machine Learning Notebooks](2019/adw-machine-learning)
* [Provisioning Autonomous Transaction Processing](2019/atp-provisioning)
* [Using Performance Hub to Analyze Resource Demand from Queries](2019/atp-performance-hub)
* [Running APEX on ATP 1] - Comning soon
* [Running APEX on ATP 2] - Comning soon
* [Create a Virtual Machine Instance Using Oracle Cloud Infrastructure Compute](2019/oci-vm)

repository: christytan/learning-library

repo_name: christytan/learning-library


text:
# An Introductory Resource for High-Performance Computing

<!--- deck text start --->

The *Survey of Methodologies, Approaches, and Challenges in Parallel Programming Using High-Performance Computing Systems* paper, published in 2020, explores some of the state-of-the-art methodologies and solutions supporting the development of parallel applications for modern high-performance computing systems.

<!--- deck text end --->

#### Contributed by [Rinku Gupta](https://github.com/rinkug)
#### Publication date: Apr 27, 2021

Resource information | Details
:--- | :---
Paper title | Survey of Methodologies, Approaches, and Challenges in Parallel Programming Using High-Performance Computing Systems
Authors | Pedro Valero-Lara, Paweł Czarnul, Jerzy Proficz and Krzysztof Drypczewski
Publication | 2020, Scientific Programming Journal, DOI: [10.1155/2020/4176794](https://doi.org/10.1155/2020/4176794)
Length | ~8,500 words, 45 min. read

<!--- deck body start --->

The *Survey of Methodologies, Approaches, and Challenges in Parallel Programming Using High-Performance Computing Systems* paper was published in 2020 in the Scientific Programming Open Access Journal. This article provides a good start for identifying and understanding some current trends in high-performance computing and some of the challenges to be addressed in the near future.

The paper provides a review of some of the contemporary methodologies and APIs for parallel programming. It also gives examples of representational technologies and classifies them by target system type, memory types, one-sided/two-sided communication patterns, and programming abstraction level. The representative technologies are further analyzed based on other criteria such as programming model, languages, supported platforms, license, optimization goals, ease of programming, debugging, deployment, portability, level of parallelism etc.

BSSw.io readers, who have some scientific computing background but are relatively new to HPC and are short on time, can glean a high-level overview of HPC methodologies and practices from this paper. The reference list also provides some resources for delving deeper into each of the specific topics mentioned in the paper.

<!--- deck body end --->

<!---
Publish: yes
Pinned: no
Topics: High-performance computing (HPC), Programming languages
RSS update: 2021-04-27
--->

gha_language: Python

gha_license_id: NOASSERTION


text:
# Botmaster-telegram

[![Build Status](https://travis-ci.org/botmasterai/botmaster-telegram.svg?branch=master)](https://travis-ci.org/botmasterai/botmaster-telegram)
<!--[![Coverage Status](https://coveralls.io/repos/github/botmasterai/botmaster-telegram/badge.svg?branch=master)](https://coveralls.io/github/botmasterai/botmaster-telegram?branch=master)-->
[![npm-version](https://img.shields.io/npm/v/botmaster-telegram.svg)](https://www.npmjs.com/package/botmaster-telegram)
[![license](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](LICENSE)

This is the Telegram integration for botmaster. It allows you to use your
botmaster bot on Telegram.

This package works with botmaster v3;
---

Botmaster is a lightweight chatbot framework. Its purpose is to integrate your existing chatbot into a variety of messaging channels.

## Documentation

Find the whole documentation for the framework on: http://botmasterai.com/documentation.latest

## Installing

```bash
yarn add botmaster-telegram
```

or

```bash
npm install --save botmaster-telegram
```

## Credentials

All you need here is an authToken. In order to get one, you will need to either create a new bot on telegram.

Basically, you'll need to send a `/newbot` command(message) to Botfather (go talk to him [here](https://web.telegram.org/#/im?p=@BotFather)). Once you're done with giving it a name and a username, BotFather will come back to you with your authToken. Make sure to store it somewhere. More info on BotFather can be found [here](https://core.telegram.org/bots#create-a-new-bot ) if needed.

For more on Telegram, you can find the telegram api docs [here](https://core.telegram.org/bots/api)

## Webhooks

Setting up your webhook requires you to make the following request outside of Botmaster (using curl for instance or a browser):

```http
https://api.telegram.org/bot<authToken>/setWebhook?url=<'Your Base URL'>/telegram/webhook1234
```

>Because Telegram doesn't send any type of information to verify the identity of the origin of the update, it is highly recommended that you include a sort of hash in your webhookEndpoint. I.e., rather than having this: `webhookEndpoint: '/webhook/'`, do something more like this: `webhookEndpoint: '/webhook92ywrnc9qm4qoiuthecvasdf42FG/'`. This will assure that you know where the request is coming from.

>If you are not too sure how webhooks work and/or how to get them to run locally, go to [webhooks](/getting-started/webhooks) to read some more.

## Code

```js
const Botmaster = require('botmaster');
const TelegramBot = require('botmaster-telegram');
const botmaster = new Botmaster();

const telegramSettings = {
  credentials: {
    authToken: 'YOUR authToken',
  },
  webhookEndpoint: '/webhook1234/',
};

const telegramBot = new TelegramBot(telegramSettings);
botmaster.addBot(telegramBot);

botmaster.use({
  type: 'incoming',
  name: 'my-middleware',
  controller: (bot, update) => {
    return bot.reply(update, 'Hello world!');
  }
});
```

#### Note on attachment types and conversions

Attachment type conversion works as such for __Telegram__:

| Telegram Type | Botmaster conversion
|--- |---
| audio | audio
| voice  | audio
| photo  | image
| video  | video
| location  | location
| venue  | location

`contact` attachment types aren't supported in Messenger. So in order to deal with them in Botmaster, you will have to look into your `update.raw` object which is the standard Telegram update. You will find your contact object in `update.raw.contact`.

Also, concerning `location` and `venue` attachments. The url received in Botmaster for Telegram is a google maps one with the coordinates as query parameters. It looks something like this: `https://maps.google.com/?q=<lat>,<long>`

A few of you will want to use attachments with your `socket.io` bots. Because the Botmaster message standard is the Facebook Messenger one, everything is URL based. Which means it is left to the developer to store both incoming and outgoing attachments.

## License

This library is licensed under the MIT [license](LICENSE)

repository: StefanSchuck/botmaster-telegram

repo_name: StefanSchuck/botmaster-telegram


text:
# A typical development lifecycle

As said before, Convector doesn't require `Lerna` to run, but we highly recommend it. This starter project's source code can be found [here](https://github.com/worldsibu/convector-example-drug-supply-chain).

We also like mono-repos, and even though they are not required here either, this examples works like that.

//

Based on the previous explanation the flow of your application would look like:

* Your front end calls your api or backend service.
* Your backend service will run under de identity of a blockchain participant.
* Your backend can call any of three components:
  * The World State database. (it can be done by injecting a Convector **storage** to your referenced model)
  * The chaincodes inside the peers. (it can be done by injecting a Convector **adapter** to your Controller Client generated file from your programmed chaincode controller)
  * Another off-chain service.

 Containing your smart contracts.
  * It is usually made up of front end modules, backend or APIs, peers (nodes) which run the smart contracts.
* A development environment (a fullblown test blockchain) created by the [Development-Environment](https://github.com/worldsibu/convector/blob/develop/tutorials/dev-env.md).
* A set of tools to interact with the blockchain, such as [Chaincode-Manager](https://github.com/worldsibu/convector/blob/develop/tutorials/chaincode-manager.md).

If seen closely, you get all those commands your lifecycle development will need.

* cc:* these are the commands to handle the installation, upgrade or invoke of your chaincodes.
  * A chaincode usually needs to be 1.) packaged 2.) installed on each peer 3.) instantiated
    * There are helpers among these helpers. For example `npm run cc:start 1.0` will install your chaincode for the first time by calling `cc:package`, `cc:install` and lastly `cc:instantiate`. But we keep each task there for granularity and empowering you for more advanced scenarios.
  * If upgrading the code (like applying a fix) you need to 1.) package 2.) install on each peer 3.) upgrade on one peer.
* env:* these are related to the blockchain components running on your computer. The names are clear by themselves.

1. Code your chaincode.
2. Test it locally (we encourage to make unit testing through the mock adapter, since testing against the blockchain takes a lot of time due to the installation process).
3. Deploy to the blockchain! Probably you haven't provisioned the blockchain yet, so you can run `npm run env:restart`.
4. And install your chaincode `npm run cc:start 1.0`, it will call the previously seen tasks which uses each of the  `...chaincode.config.json` files (you need to generate one for each organization to install it on every participant). But before:
5. Compile your chaincode project. Let's say your chaincode project is at 'root/@worldsibu/chaincodes/cc-drug' (like in the source code referenced to this project) so you would add these tasks at the `package.json`.  Run `npm run build` at that folder, or if using lerna `lerna run build --scope @worldsibu/convector-example-dsc-cc-drug`.
7. Be sure that each `...chaincode.config.json` file is configured correctly with the packages and references to your project and the name you like to give to your chaincode!
2. Proceed to run `npm run cc:start 1.0`.
3. This installation task may take some time.
4. A new folder was generated at the root of your project called "chaincode" it is automatically regenerated on each package.
5. A common next task would be adding your chaincode base components to your backend (model and controller - in the case of Convector when compiling a chaincode project a clean Controller Client gets built for you to inject the implementation of the logic).
6. Add the chaincode project as dependencies to you backend project. We like at least this structure inside your server project:
  1. utils / - controller.ts, - helper.ts, - models.ts, - index.ts
7. The reason for those files (as you can see in the source code referenced) is to inject the Adapters and Storages used on this specific project.
8. Since we are using the official SDK from the Hyperledger Project, we need to provide a **Network Profile**. It is a simple JSON containing the setup of your network. After you started the blockchain in your computer with `npm run env:restart` a folder was automatically created with the name `.convector-dev-env` go and copy each file `.convector-dev-env/examples/org1.network-profile.yaml` and `.convector-dev-env/examples/org2.network-profile.yaml` those are examples of that network profile you need. Change the setting accordingly to your project and store them in an accesible path for the server. We like to copy them to a `/config` folder inside the server. Checkout the referenced source code to see it in action.
9. That newly created folder `.convector-dev-env` will be referenced by a lot of files to access the certificates with which your servers and users will run. For example, as seen before, the network profile (which is used by the Fabric SDK needs them), the chaincode manager will also require them to access the admin credentials to install chaincodes and also de dev env which itself generated them.

We recommend checking out this project to put every required component where needed [access code](https://github.com/worldsibu/convector-example-drug-supply-chain).

repository: hyperledger-labs/convector

repo_name: hyperledger-labs/convector


text:
# Mining Minds
[![Version](https://img.shields.io/badge/mining%20minds-version%202.5-green.svg)](http://www.miningminds.re.kr/english/)
[![License](https://img.shields.io/badge/Apache%20License%20-Version%202.0-yellowgreen.svg)](https://www.apache.org/licenses/LICENSE-2.0)

<!--Mining Minds is a collection of services, tools and techniques working collaboratively to investigate on human’s daily routines to provide a personalized well-being and health-care support-->

“Mining Minds” is a novel framework aimed at comprehensively mining human’s daily life data generated from heterogeneous resources for producing personalized health and wellness support. Mining Minds philosophy revolves around the concepts of data, information, knowledge and service curation, which refer to the discovery, processing, adaptation and evolution of both contents and mechanisms for the provision of high quality support services. Motivated by these concepts, a multilayer architecture is particularly devised for Mining Minds, illustrated in the following figure:

[<img src="https://github.com/ubiquitous-computing-lab/mining-minds/blob/gh-pages/figures/landing-page/MMv2.5-Architecture-Diagram.jpg">](http://uclab.khu.ac.kr/)

In a nutshell, the data curation layer (DCL) is in charge of processing and persisting the data obtained from the multimodal data sources (MDS), which abstractly defines the possible sources of user health and wellness data.  is includes, but is not limited to, data from social networks, questionnaires, wearable biomedical devices or ambient intelligence systems.

The data processed by DCL is primarily used by the information curation layer (ICL) to infer low-level and high-level person-centric information.  is information mainly describes the user context and behavior, and, to some extent, their physical, mental and social state.  e information extracted by ICL is leveraged by the knowledge curation layer (KCL) to nurture and evolve the health and wellness knowledge primarily created by human experts.

Data, information and knowledge are used by the service curation layer (SCL) to create intelligent health and wellness support services, mostly in the form of smart coaching and support recommendations. All the contents and processes are accommodated in terms of security and privacy by the supporting layer (SL), which also provides analysis of user experience, feedback and trends to guarantee the highest personalization.

Technical details regarding Mining Minds platform can be found in the following publication

Oresti Banos, Muhammad Bilal Amin, Wajahat Ali Khan, Muhammad Afzal, Maqbool Hussain, Byeong Ho Kang and Sungyong Lee, <b>"The Mining Minds Digital Health and Wellness Framework" </b>, BioMedical Engineering OnLine (SCIE, IF:1.43), DOI:10.1186/s12938-016-0179-9, 2016

visit: [miningminds.re.kr](http://www.miningminds.re.kr/)

# Features
##  Big Data Analysis and Modeling
Data acquisition from diverse sources of data in online and offline manner, unified representation and an interoperable and sharable model.

##  Human Behavior Analysis
User interests and preferences learned from historical and contextual data from emotion, activity, diet and sleep patterns.

##  Personalized Recommendation
Context-aware recommendation generation for the target users according to their needs and situation.

##  Knowledge Maintenance
High quality knowledge creation and feedback-based knowledge maintenance.

##  Adaptive UI/UX
UI/UX Authoring tool » Provide UX based adaptive UI

# Authors

#### Principal Investigator (PI)

- Professor Sungyoung Lee<EMAIL_ADDRESS>
#### Project Manager (PM)

- Dr. Oresti Banos<EMAIL_ADDRESS>
#### Project Manager & Team Lead (PM - TL)

- Dr. Muhammad Bilal Amin<EMAIL_ADDRESS>
# License
The code is licensed under the [Apache License Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)

repository: ubiquitous-computing-lab/Mining-Minds

gha_language: JavaScript

repo_name: ubiquitous-computing-lab/Mining-Minds


text:
# COMPAS and Docker

Docker has been added to COMPAS to reduce time and effort required to set up the COMPAS deployment environment.

Instead of having to install and configure several libraries and tools (e.g. python/pip, numpy, g++, boost) which can vary considerably beween operating systems and existing toolchains, users can instead opt to install Docker and run COMPAS with a single command.

This also gives users the ability to run COMPAS on cloud solutions like [AWS EC2](https://aws.amazon.com/ec2/) or [Google Compute Engine](https://cloud.google.com/compute) where hundreds of cores can be provisioned without having to manually configure the environment.

Docker works by creating an isolated and standalone environment known as a [container](https://www.docker.com/resources/what-container).
Containers can be created or destroyed without affecting the host machine or other containers*.

Containers are instances of images. An image is a pre-defined setup/environment that is instantiated when started as a container (containers are to images what objects are to classes). More [here](https://stackoverflow.com/questions/23735149/what-is-the-difference-between-a-docker-image-and-a-container#:~:text=An%20instance%20of%20an%20image,of%20layers%20as%20you%20describe.&text=You%20can%20see%20all%20your,an%20image%20is%20a%20container.) on the relationship between images and container.

Containers are (almost) always run as a Linux environment. A major benefit of this is the ability to run Linux applications in a Windows or MacOS environment without having to jump through hoops or have a diminished experience.

Image definitions can be defined by users (e.g. Dockerfiles); there are also standard images publicly available on [Docker Hub](https://hub.docker.com/)

All that is required to start using COMPAS with Docker is the "Usage" section (the "CI/CD" section is also highly recommended).
The other sections are provided for extra info.

\* Containers can still interact with each other and the host machine through mounted directories/files or exposed ports.

---

## Usage

N.B. This section assumes [Docker](https://www.docker.com/) has been installed and is running.
For Windows and MacOS users, see [here](https://www.docker.com/products/docker-desktop).

### Installing

The latest compiled version of COMPAS (dev branch) can be retrieved by running
```docker pull teamcompas/compas```

Other versions can be used by adding a version [tag](https://docs.docker.com/engine/reference/commandline/tag/).
For example, COMPAS version 2.12.0 would be `teamcompas/compas:2.12.0`.
To see all available versions, go to the TeamCOMPAS docker hub page [here](https://hub.docker.com/u/teamcompas).

### Running

COMPAS can still be configured via command line arguments passed to the COMPAS executable or via a `pythonSubmit.py` file.

#### Run pythonSubmit.py

To run COMPAS via a `pythonSubmit.py` file, the command is a little more complex.

```
docker run                                                  \
    --rm                                                    \
    -it                                                     \
    -v $(pwd)/compas-logs:/app/COMPAS/logs                  \
    -v $(pwd)/pythonSubmit.py:/app/starts/pythonSubmit.py   \
    -e COMPAS_EXECUTABLE_PATH=/app/COMPAS/bin/COMPAS        \
    -e COMPAS_LOGS_OUTPUT_DIR_PATH=/app/COMPAS/logs         \
    teamcompas/compas                                       \
    python3 /app/starts/pythonSubmit.py
```

Breaking down this command:

`docker run`
creates a container

`--rm`
[Clean up](https://docs.docker.com/engine/reference/run/#clean-up---rm)
destroy the container once it finishes running the command

`-it`
short for [-i and -t](https://docs.docker.com/engine/reference/run/#foreground) - provides an interactive terminal

`-v <path-on-host>:<path-in-container>`
[Bind mounts](https://docs.docker.com/storage/bind-mounts/)
mount `<path-on-host>` to `<path-in-container`>
This time we not only want to get the output from COMPAS on the host machine, we also want to supply a `pythonSubmit.py` to the container from the host machine.

`-e VAR_NAME=value`
[Environment variables](https://docs.docker.com/engine/reference/run/#env-environment-variables)
set the environment variable `VAR_VAME` to `value`

`teamcompas/compas`
the image to run

`python3 /app/starts/pythonSubmit.py`
the command to run when the container starts

#### Run the COMPAS executable

To run the COMPAS executable directly (i.e. without `pythonSubmit.py`)
```
docker run                                  \
    --rm                                    \
    -it                                     \
    -v $(pwd)/compas-logs:/app/COMPAS/logs  \
    teamcompas/compas                       \
    bin/COMPAS                              \
    --number-of-binaries=5                  \
    --outputPath=/app/COMPAS/logs
```

Breaking down this command:

`docker run`
creates a container

`--rm`
[Clean up](https://docs.docker.com/engine/reference/run/#clean-up---rm)
destroy the container once it finishes running the command

`-it`
short for [-i and -t](https://docs.docker.com/engine/reference/run/#foreground) - provides an interactive terminal

`-v <path-on-host>:<path-in-container>`
[Bind mounts](https://docs.docker.com/storage/bind-mounts/)
mount `<path-on-host>` to `<path-in-container>`
In this instance, make it so `$(pwd)/compas-logs on my machine is the same as `/app/COMPAS/logs` inside the container

`teamcompas/compas`
the image to run

`bin/COMPAS`
the command to run when the container starts

`--number-of-binaries`
anything after the given start command is passed to that command, in this case, the flag to set the number of binaries

`--outputPath /app/COMPAS/logs`
same as above, anthing after the start command is given to that start command, here it forces logs to go to the directory that is mapped to the host machine

More info on `docker run` [here](https://docs.docker.com/engine/reference/run/)

NOTE 1:

Two new environment variables have been added, both of these apply to `pythonSubmit.py` only and are non-breaking changes.

`COMPAS_EXECUTABLE_PATH` is an addition to the default `pythonSubmit.py` that overrides where `pythonSubmit.py` looks for the compiled COMPAS.
This override exists purely for ease-of-use from the command line.

`COMPAS_LOGS_OUTPUT_DIR_PATH` is also an addition to the default `pythonSubmit.py` that overrides where logs are placed.
The override exists because the mounted directory (option `-v`) is created before COMPAS runs. COMPAS sees that the directory where it's supposed to put logs already exists, so it created a different (i.e. non-mapped) directory to deposit logs in.

NOTE 2:

The `docker run ...` examples above both use the `-it` options.
If you want to run multiple instances of COMPAS, I would highly recommend using [detached mode](https://docs.docker.com/engine/reference/run/#detached--d) (`-d`) instead.
All container output will be hidden.

An example where this would be useful is if you were running 4 instances of COMPAS at once.
You could copy/paste the following into the terminal...
```
docker run --rm -d -v $(pwd)/compas-logs/run_0:/app/COMPAS/logs -v $(pwd)/pythonSubmitMMsolar_01.py:/app/starts/pythonSubmit.py teamcompas/compas python3 /app/starts/pythonSubmit.py &

docker run --rm -d -v $(pwd)/compas-logs/run_1:/app/COMPAS/logs -v $(pwd)/pythonSubmitMMsolar_02.py:/app/starts/pythonSubmit.py teamcompas/compas python3 /app/starts/pythonSubmit.py &

docker run --rm -d -v $(pwd)/compas-logs/run_2:/app/COMPAS/logs -v $(pwd)/pythonSubmitMMsolar_03.py:/app/starts/pythonSubmit.py teamcompas/compas python3 /app/starts/pythonSubmit.py &

docker run --rm -d -v $(pwd)/compas-logs/run_3:/app/COMPAS/logs -v $(pwd)/pythonSubmitMMsolar_04.py:/app/starts/pythonSubmit.py teamcompas/compas python3 /app/starts/pythonSubmit.py
```

...which would run 4 separate instances of COMPAS, each with its own `pythonSubmit.py` file and logging directory, and all console output supressed.

You may want to check the console output to see how far into the run COMPAS is.
The command for this is `docker logs <container_id>`.
You can get the container id by running `docker ps`.

---

## CI/CD

The latest version of COMPAS (dev branch) is available at `teamcompas/compas`.
This is provided automatically by CI/CD.

Whenever a push to [TeamCOMPAS/dev](https://github.com/TeamCOMPAS/COMPAS/tree/dev) a continuous deployment process automatically [builds](https://docs.docker.com/engine/reference/commandline/build/) a new image and deploys it to DockerHub with a `tag` that corresponds to the value of `VERSION_STRING` in `constants.h`.

At time of writing, [GitHub Actions](https://github.com/features/actions) is facilitating the above process. While this is convenient (because it's free and well supported) it is quite slow. I have plans to create a [runner](https://help.github.com/en/actions/getting-started-with-github-actions/core-concepts-for-github-actions#runner) locally with a high core count that can be used to compile COMPAS quickly, but haven't gotten around to it yet.

You can realistically expect the latest COMPAS docker image to be available 5 - 10 minutes after pushing/merging.

The Github Actions configuration is in `/.github/workflows/dockerhub-ci.yml`.

Atlassian has a [good writeup](https://www.atlassian.com/continuous-delivery/principles/continuous-integration-vs-delivery-vs-deployment) about what CI/CD is.

---

## Bonus Info

### Dockerfile

The [Dockerfile](https://docs.docker.com/engine/reference/builder/) defines how the docker image is constructed.

Images are created as a combination of layers.
During the build process each layer is cached and only updated on subsequent builds if that layer would change.

The Dockerfile for COMPAS is made up of 8 layers.

```FROM ubuntu:18.04```
Use [Ubuntu 18.04](https://hub.docker.com/_/ubuntu) as a base (provided by Docker Hub)
[https://docs.docker.com/engine/reference/builder/#from](FROM) docs

```WORKDIR /app/COMPAS```
Effectively `cd /app/COMPAS` within the container.
[WORKDIR](https://docs.docker.com/engine/reference/builder/#workdir) docs

```RUN apt-get update && apt-get install -y ...```
Install the required dependencies.
`-y` so there's no prompt to install any of the packages.
`update` and `install` are in the same layer because now if there are any updates, it will force all of the dependencies to be re-installed
[RUN](https://docs.docker.com/engine/reference/builder/#run) docs

```RUN pip3 install numpy```
Install numpy.
[RUN](https://docs.docker.com/engine/reference/builder/#run) docs

```COPY src/ src/```
Copy `./src/` directory from the local machine to `./src` in the container (remembering that `WORKDIR` changes the cwd).
[COPY](https://docs.docker.com/engine/reference/builder/#copy) docs

```RUN mkdir obj bin logs```
Create the directories required by COMPAS.
[RUN](https://docs.docker.com/engine/reference/builder/#run) docs

```ENV COMPAS_ROOT_DIR /app/COMPAS```
Set the required environment variable(s).
[ENV](https://docs.docker.com/engine/reference/builder/#env) docs

```RUN cd src && make -f Makefile.docker -j $(nproc)```
Make COMPAS using a specific makefile (more below) and as many cores as possible.
[RUN](https://docs.docker.com/engine/reference/builder/#run) docs

Dockerfiles will usually end with a `CMD` directive that specifies what command should run when the container is started.
COMPAS doesn't have a `CMD` directive because some users will want to run the executable directly and some will want to use `pythonSubmit.`.
[CMD](https://docs.docker.com/engine/reference/builder/#cmd) docs

### Makefile.docker

A separate makefile is required for Docker in this scenario for two reasons.

1. To separate compiled files from source files
2. To prevent the usage of `-march=native`

`-march=native` is a fantastic optimisation for users who compile and run COMPAS on the same machine, however it causes fatal errors when running COMPAS on a machine that it was not compiled for.
[Docs](https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html) for `-march`.
> This selects the CPU to generate code for at compilation time by determining the processor type of the **compiling machine**.

> Using -march=native enables all instruction subsets supported by the local machine (hence the result might not run on different machines).

---

branch_name: refs/heads/dev


text:
How To Insert Information Into A Table
======================================

In this lesson we built up on the previous ‘People Table’. This allowed for us
to add commands which lets us insert new people in to the table and also
retrieve all the people in the table.

You can view each script in the folder, they are numbered for ease of knowing
what order to view them, also there is a csv file in the folder which is the
data exported from the people table.

gha_language: CSS


text:
## Weight Loss Is Just One Aspect of Getting Healthy

We speak of losing weight as synonymous as getting healthy or fit. And for good reasons. Bad health is most visibly manifested by excessive weight. In turn, excessive body weight affects our mobility, our athletic performance, our appearance and our self-image.

To many, losing weight becomes the end-goal. This approach is problematic for a number of reasons. Losing weight when you are overweight can improve your appearance and performance, but done the wrong way, it can hurt other parts of your health.

Does your diet and exercise leave you tired, in bad mood, or in pain?

Obsessing with low weight has also lead to unhealthy practices. Liposuction, extreme wight loss supplements, practices, are obvious examples. Less obviously many endurance atheletes might be compromising their health in pushing to burn more calories.

Being underweight can be just as unhealthy as being overweight. It is possible to be too low in body fat, although most of us would not mind that.

## You Cannot Exercise Away A Bad Diet

We've all heard it. "I'll have this cupcake and then run more this evening to burn it off."

 Getting it back into shape is going to take time.

## Calories In Calories Out is Just A (Small) Part of the Equation

## Exercise Only Make You Strong If You Recover

## Most Diet Work In the Short Term, But It's the Long Term That Counts


text:
9.3: Popover Dismiss on next click example
==========================================
**Primary Actor**: User

**Scope**: Ngx-bootstrap DEMO / BS version 3&4

**Goal**: Show user how to dismiss popovers using focus trigger

Main success scenario:
----------------------
1. User opens Popover demo page
2. User clicks on Dismiss on next click sub-menu
3. User see clickable button "Dismissible popover"
4. When user clicks on "Dismissible popover", then popover-container shown with specific text
5. When user clicks on "Dismissible popover" again, then nothing happens
6. When user move mouse to the popover-container and click there, then popover-container disappeared

Extentions:
-----------
6.1. When user move mouse out of the popover-container and button, and click anywhere, then popover-container disappeared

Variations:
-----------
2*. User scroll to Dismiss on next click sub-menu

repository: valor-software/ngx-bootstrap

branch_name: refs/heads/development

repo_name: valor-software/ngx-bootstrap


text:
Index has been deprecated

# Index

Index is a small Windows utility that allows you to launch applications and documents in just a few quick keypresses. It is inspired by Alfred on OSX.

The Windows key in Windows 10 covers almost all functionality that was intended to be offered by Index, and so active development has ceased.

repository: Stuie/Index

repo_name: Stuie/Index


text:
# GDScript Formatter

A [vscode extension](https://marketplace.visualstudio.com/items?itemName=Razoric.gdscript-toolkit-formatter)
  that runs Scony's [python-based GDScript formatter.](https://github.com/Scony/godot-gdscript-toolkit)

## Features

- Formats GDScript code using the `Format Document` command, or when
  format-on-save is activated.
- Command - `GDScript Format: Organize Script`: Re-orders GDScript
  elements of a script according to the official
  [style guide](http://docs.godotengine.org/en/latest/getting_started/scripting/gdscript/gdscript_styleguide.html#code-order).
- Command - `GDScript Format: Convert multiline comments to # comments`:
  Converts old-style multiline blocks to # comment blocks. """ Multiline
  strings """ are not optimized away by Godot when the game is built,
  and so are being obsoleted from the documentation.

![Formatted output](assets/banner.png)

## Requirements

- `Python3` and `pip` should both be installed.
- The `GDToolkit` module should be installed via pip, though if it is missing
  you will be prompted to install it.

## Extension Settings

- `gdscript_formatter.line_size`: The maximum size a given line can be before
  it is wrapped.

## Known Issues

None yet

## Release Notes

### 1.1.0

Add the `Organize Script` and `Convert multiline comment blocks to #` commands.

Fix a bug that caused the last character, if it wasn't a newline, to repeat.

### 1.0.2

Fix to the README markdown and package.json

### 1.0.0

Initial release of the VSCode extension of GDScript Formatter.

repository: NathanLovato/godot-gdscript-toolkit

repo_name: NathanLovato/godot-gdscript-toolkit


text:
## Add a profile page

Add a Your_Full_Name.md file (e.g: **Nikola_Tesla.md**) to the profiles directory(/profiles/**Nikola_Tesla.md**). Use any combination of content, styles and Markdown you'd like. Here is an example:

```markdown
# Your Full Name (e.g: Microclubist)

### Location
Your City/Country

### Academics
e.g: Uiversity of Science and Technology Houari Boumediene, Algeria. (USTHB)
- Computer Science.

### Interests
- Things you like, e.g: cookies, video games and code.
- Something Else, e.g: more cookies...

### Development
- e.g: I am not a developer, i'm an elictrical electrical engineer.
- e.g: full stack developer.
- e.g: video games developer.

### Profile Link
- [GitHib username](GitHub profile link)
- [Linkedin name](Linkedin profile url link)

### GitHub Page/Website (if availble)
[GitHib Page name](GitHub Page url)

### Other projects
[Project name](Project url link)
```


text:
# NgxValidate

This project is still a work-in-progress and, although it works fine, it should be used with caution.

## Quickstart

Just add the core package to your project with either `yarn add @ngx-validate/core` or `npm install @ngx-validate/core` and import core module to your main module like this: `NgxValidateCoreModule.forRoot()`

\*[Stackblitz Example.](https://stackblitz.com/edit/ngx-validate)

Further information will be provided soon.

## Roadmap

- [x] Dynamic display of validation errors

- [x] Support for error blueprints with parameters

- [x] Separate directives to mark style and render targets in DOM

- [x] Meaningful defaults, instant start

- [x] Flexible configuration on module, form group, and form control level

- [x] Permissive license (MIT)

- [ ] Usage documentation

- [ ] GitHub Pages implementation

- [ ] Issue submission template

- [ ] Contribution documentation

- [ ] Tests

repository: gokhanipek/ngx-validate

repo_name: gokhanipek/ngx-validate


text:
# ⚠ This repo is obsolete

[DMT GUI KIT](https://github.com/dmtsys/dmt-gui-kit) will replace it ...

# DMT Frontend Components

Component library used in DMT Apps.

## Install

Usually no need to install, comes included in DMT ENGINE and DMT APPS reference that version.

## Usage

```js
import { Button } from 'dmt-frontend-components';
```

See [src/index.js](./src/index.js) for all exported components.

The library also includes a CSS file for various styling. Copy [src/assets](./src/assets) into your project and include [src/assets/css/global.css](./src/assets/css/global.css) in your `index.html`.
UPDATE1: don't include in index.html but import in main.js after moving to vite!

UPDATE2, check hot to automatically copy this asset in vite...
this is how it is done in dmt-connect currently (which is still on rollup directly instead of vite)

copy({
  targets: [{ src: './node_modules/dmt-frontend-components/src/assets', dest: 'public/build' }]
}),

repository: uniqpath/dmt

repo_name: uniqpath/dmt


text:
# Kundan Bhasin's Portfolio

<img src="pic.png" alt="Kundan Bhasin" width="300">

Welcome to my Portfolio.

Visit my Portfolio Site [here](https://kundanb.netlify.app).

## About Me

Hi! I am Kundan Bhasin. I belong to Modinagar, a small city in India. I am a passionate Front-end Developer and a Programming enthusiast. I have 3+ years of experience in the Design and Development of Web Applications. I am a self-taught developer and a practical personality. I always like to learn and develop new skills. I hold strong fundamentals in programming with good practical experience. I aspire to be a highly skilled web developer with a stable stand in an MNC.

## Skills

I have worked on various tech-stacks. But techologies I am confident with are:

- HTML5
- CSS3 + SCSS
- JavaScript + JQuery
- React.js + Redux
- Node.js + Express.js + MySQL
- Core PHP + MySQL
- Firebase
- REST API

### Misc. Skills

- SEO
- Git + GitHub
- Netlify + Heroku

## Stats

![Kundan Bhasin's GitHub Stats](https://github-readme-stats.vercel.app/api?username=kundanb&theme=radical)

![Most Used Languages](https://github-readme-stats.vercel.app/api/top-langs?username=kundanb&layout=compact&theme=radical)

## Professional Details

- **Industry:** Software Development
- **Total years of experience:** 3
- **Eligible to work in:** India
- **Preferred Locations:** Noida, Chennai, Bangalore, Coimbatore

## Personal Details

- **Date of Birth:** 11 June, 2000
- **Gender:** Male
- **Nationality:** Indian

---

**Thank You**


text:
---
asphalt: 0
country: ['Poland', 'Slovakia']
creationDate: '2020-02-23'
date: "2020-02-23"
difficulty: 2
distance: 11.4
endTime: '13:00'
ferns: null
finishPoint: null
highestMountain: Pilsko
mapaTurystyczna: mapa-turystyczna.pl/route/rxek
mnpm: 1557
mountainRange: ['Żywiec Beskids']
mountains: null
parkingCords: goo.gl/maps/g6TAZD6MxfCv26qh7
startTime: '9:00'
startingPoint: Glinne, mountain pass
title: Pilsko (from Glinne)
type: tour
wiki: https://en.wikipedia.org/wiki/Pilsko
---

Fast trip. I did start on a Glinne pass. I remember a time when this place was alive. It was before Polish borders opened due to [Schengen](https://en.wikipedia.org/wiki/Schengen_Area) regulations.

I left my car near a small shop that sells traditional polish cheeses.

I was checking a forecast and I had a little amount of time, till it starts raining, that’s why I decide to start from here and I think that is the fastest way to reach Pislko from my perspective.

I decide to follow the blue border path and it was a mistake because I lost it. It is not marked very well. Probably if not mapaturystyczna I would retreat. By using navigation I reached [Góra Pięciu Kopców](https://pl.wikipedia.org/wiki/G%C3%B3ra_Pi%C4%99ciu_Kopc%C3%B3w). There was a huge amount of snow on the top, so even there it was a problem to find the right path to the summit.
So, if you are not familiar with Pilsko during winter, probably you should choose the black path and don’t follow the blue one. However, I think that without snow it will be easy to follow blue.

There is a photo of some strange wall with graffiti. About 1 year ago there was a fire of old shelter on Hala Miziowa. That's what's left.

repository: tobob/just-walking

repo_name: tobob/just-walking


text:
# SafeRxJS

Manages safe RxJS subscriptions.

```ts
const safeRxJS: SafeRxJS = new SafeRxJS();
```

This class is intended to avoid memory leaks and race conditions when using Observable subscriptions.

## API

### Exposed Properties

#### `readonly destroy$: Subject<void>`

A Subject to be emitted on `onDestroy()` to complete subscriptions.

#### `readonly safeSubscription: SafeSubscription`

Safely store disposable resources, such as the execution of an Observable.

See [SafeSubscription](../safe-subscription/README.md).

### Exposed Methods

#### `takeUntilDestroy<T>(): MonoTypeOperatorFunction<T>`

Emits the values emitted by the source Observable until the `onDestroy` method is executed.

```ts
const destroy$: Observable<any> = observable$.pipe(safeRxJS.takeUntilDestroy()).subscribe();
```

```ts
onDestroy()  '---------(x|)'
destroy$     '-x-x-x-x-x-x-'
subscribe    '-x-x-x-x-|   '
```

#### `onDestroy(): void`

Disposes the resource held by Observable subscriptions.

```ts
safeRxJS.onDestroy();
```

## Example of use

```ts
import { HttpClient } from '@angular/common/http';
import { OnDestroy, OnInit } from '@angular/core';
import { SafeRxJS, SubscriptionFn } from '@kaikokeke/common';
import { fromEvent, Observable } from 'rxjs';
import { take } from 'rxjs/operators';

class TestClass implements OnInit, OnDestroy {
  readonly safeRxJS: SafeRxJS = new SafeRxJS();

  constructor(protected readonly http: HttpClient) {}

  ngOnInit(): void {
    fromEvent(document, 'click')
      .pipe(take(5), safeRxJS.takeUntilDestroy())
      .subscribe({
        next: (value: Event) => {
          // do something
        },
      });
  }

  load(options: any): void {
    const loadFn: SubscriptionFn = () =>
      this.http
        .get('https://test.com', options)
        .pipe(take(1))
        .subscription({
          next: (value: any) => {
            // do something
          },
        });

    safeRxJS.safeSubscription.add('loadFn', loadFn, options);
  }

  ngOnDestroy(): void {
    safeRxJS.onDestroy();
  }
}
```

repository: CarmeloRicarte/kaikokeke

repo_name: CarmeloRicarte/kaikokeke


text:
# esri-flux-react  [![Build Status](https://travis-ci.org/Robert-W/esri-flux-react.svg?branch=master)](https://travis-ci.org/Robert-W/esri-flux-react)
Simple demo application using Esri's JavaScript API and React. It also shows how to use the Flux architecture in a map based application.  This is using a naive implementation of flux I wrote myself based off of [React's TODO MVC example](https://facebook.github.io/flux/docs/todo-list.html), it's good at demonstrating the concepts of Flux but is by no means intended to be a Flux library.  It would work perfectly fine in production on a simple app but once your app gets larger and has multiple stores, especially stores that depend on each other, you may want to use something like [Alt](http://alt.js.org/) which has ```waitsFor``` in the dispatcher as well as other extras and is much more battle tested.

## Demo
> The Demo is currently using the react-motion branch.

[http://robert-w.github.io/esri-flux-react/](http://robert-w.github.io/esri-flux-react/)

### Getting Started
This project requires node.js and bower.

1. Run (may need sudo depending on how you installed node): ```npm install```
2. Run: ```bower install```

### Scripts

#### Development
Run: ```npm start```

This will compile all stylus, jade, and es6 modules, and it's using babel for es6 modules so it will compile JSX for you as well.

#### Production
Run: ```npm run dist```

Generates a minified build using a custom prerender script, requirejs optimizer, babel, stylus, jade, and gulp in a dist folder.  After running, you can look at the index.html source and you will notice a big string of React markup generated from prerender.js.

##### Notes
Check out the react-motion branch.  Instead of using css animations on the basemap gallery it is using [react-motion](https://github.com/chenglou/react-motion) by [@chenglou](https://github.com/chenglou), I like this version much better and it will soon be merged in to master :)

##### Known Issues
Build commands may trip up on windows, there is an ```npm run  distWin``` which can be used for a custom build on windows.


text:
---
layout: page
title: Amazon Search
permalink: /amazon/
---

<script type="text/javascript">
amzn_assoc_placement = "adunit0";
amzn_assoc_tracking_id = "contrem-20";
amzn_assoc_ad_mode = "search";
amzn_assoc_ad_type = "smart";
amzn_assoc_marketplace = "amazon";
amzn_assoc_region = "US";
amzn_assoc_default_search_phrase = "Laptops";
amzn_assoc_default_category = "All";
amzn_assoc_linkid = "bdf3b3dfbf83a791f02215bdbb7dc33f";
amzn_assoc_title = "";
amzn_assoc_search_bar = "true";
amzn_assoc_search_bar_position = "top";
</script>
<script src="//z-na.amazon-adsystem.com/widgets/onejs?MarketPlace=US"></script>

*contrem.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to amazon.com.*


text:
Galaxy for BeerDeCoded
===============

[![Docker Repository on Quay](https://quay.io/repository/bebatut/galaxy-beerdecoded/status "Docker Repository on Quay")](https://quay.io/repository/bebatut/galaxy-beerdecoded)

[BeerDeCoded](http://www.genome.beer/) is a participatory project investigate the microbial composition of a collection of commercial beers. The goal of the BeerDeCoded project is not only to extend the scientific knowledge about beer, but also to improve the public understanding of issues related to personal geno- mics, food technology, and their role in society.

For the data analysis, the BeerDeCoded project is using [Galaxy](https://galaxyproject.org/), inside a [Galaxy Docker flavor](http://bgruening.github.io/docker-galaxy-stable/) based on [ASaiM](http://asaim.readthedocs.io/en/latest/).

# Usage

## Requirements

To use Galaxy for BeerDeCoded, [Docker](https://www.docker.com/products/overview#h_installation) is required (except if you want to [setup and run the framework without using Docker](#installation-and-use-without-using-docker)).

For Linux users and people familiar with the command line, please follow the [very good instructions](https://docs.docker.com/installation/) from the Docker project. Non-Linux users are encouraged to use [Kitematic](https://kitematic.com), a graphical User-Interface for managing Docker containers.

## Launch

1. Starting the Docker container with Galaxy for BeerDeCoded: analogous to starting the generic Galaxy Docker image:

    ```
    $ docker run -d -p 8080:80 quay.io/bebatut/galaxy-beerdecoded
    ```

    Nevertheless, here is a quick rundown:

    - `docker run` starts the Image/Container

        In case the Container is not already stored locally, Docker downloads it automatically

    - The argument `-p 8080:80` makes the port 80 (inside of the container) available on port 8080 on your host

        Inside the container a Apache web server is running on port 80 and that port can be bound to a local port on your host computer.
        With this parameter you can access your Galaxy instance via `http://localhost:8080` immediately after executing the command above

    - `quay.io/bebatut/galaxy-beerdecoded` is the Image/Container name, that directs Docker to the correct path in the [Docker index](https://index.docker.io/u/bgruening/galaxy-rna-workbench/)
    - `-d` will start the Docker container in Daemon mode.

    > A detailed discussion of Docker's parameters is given in the [Docker manual](http://docs.docker.io/). It is really worth reading.

    The Docker container is run: Galaxy will be launched!

    > Setting up Galaxy and its components can take several minutes. You can inspect the state of the starting using:
    > ```
    > $ docker ps # to obtain the id of the container
    > $ docker logs <container_id>
    > ```

    The previous commands will configure, launch and populate Galaxy with the needed tools, workflows and databases. The instance will be accessible at [http://localhost:8080](http://localhost:8080).

2. Installation of the databases once Galaxy is running

    ```
    $ docker exec <container_id> run_data_managers
    ```

#### Workflows

To access to the workflows, you need to connect with the admin user (username<EMAIL_ADDRESS>password: `admin`). And you will have access to the workflows in the 'Workflow' section (Top panel)

#### Databases

Databases are automatically added to the Galaxy instance for MetaPhlAn2, HUMAnN2 and QIIME.

Sometimes the databases are not correctly seen by the tools. If it is the case, you need to force the connection between the tool and the database:

- Connect with the admin user:
    - username<EMAIL_ADDRESS>    - password `admin`
- Go to the 'Admin' section (Top panel)
- Go to 'Local data' section (Left panel)
- Click on `humann2_nucleotide_database`, `humann2_protein_database` or `metaphlan2_database` (depending on the database)
- Click on the 'Reload button' on the top

    The table must be filled

If you want other databases for HUMAnN2 or QIIME, you can install them "manually":

- Connect with the admin user:
    - username<EMAIL_ADDRESS>    - password `admin`
- Go to the 'Admin' section (Top panel)
- Go to 'Local data' section (Left panel)
- Click on 'HUMAnN2 download' (or 'Download QIIME') and choose the database you want to import

### Interactive session

For an interactive session, you can execute:

```
$ docker run -i -t -p 8080:80 quay.io/bebatut/galaxy-beerdecoded /bin/bash
```

and manually invokes the `startup` script to start PostgreSQL, Apache and Galaxy and download the need databases.

> For a more specific configuration, you can have a look at the [documentation of the Galaxy Docker Image](http://bgruening.github.io/docker-galaxy-stable/).

### Data

Docker images are "read-only". All changes during one session are lost after restart. This mode is useful to present ASaiM to your colleagues or to run workshops with it.

To install Tool Shed repositories or to save your data, you need to export the computed data to the host computer. Fortunately, this is as easy as:

```
$ docker run -d -p 8080:80 -v /home/user/galaxy_storage/:/export/ quay.io/bebatut/galaxy-beerdecoded
```

Given the additional `-v /home/user/galaxy_storage/:/export/` parameter, Docker will mount the folder `/home/user/galaxy_storage` into the Container under `/export/`. A `startup.sh` script, that is usually starting Apache, PostgreSQL and Galaxy, will recognize the export directory with one of the following outcomes:

- In case of an empty `/export/` directory, it will move the [PostgreSQL](http://www.postgresql.org/) database, the Galaxy database directory, Shed Tools and Tool Dependencies and various configure scripts to /export/ and symlink back to the original location.
- In case of a non-empty `/export/`, for example if you continue a previous session within the same folder, nothing will be moved, but the symlinks will be created.

This enables you to have different export folders for different sessions - meaning real separation of your different projects.

### Users & Passwords

The Galaxy Admin User has the username<EMAIL_ADDRESS>and the password `admin`.

The PostgreSQL username is `galaxy`, the password `galaxy` and the database name `galaxy`.
If you want to create new users, please make sure to use the `/export/` volume. Otherwise your user will be removed after your Docker session is finished.

 If you want to clean fully your Docker engine, you can follow the [Docker Cleanup Commands](https://www.calazan.com/docker-cleanup-commands/).

# Documentation

Available tools and workflows in ASaiM framework (on which the current instance is based) are described in the documentation available at [http://asaim.readthedocs.org/](http://asaim.readthedocs.org/en/latest/framework/index.html).

# Bug Reports

Any bug can be filed in an issue [here](https://github.com/bebatut/galaxy-beerdecoded/issues).

# License

Galaxy for BeerDeCoded is released under Apache 2 License. See the [LICENSE](LICENSE) file for details.

repository: bebatut/galaxy-beerdecoded

repo_name: bebatut/galaxy-beerdecoded


text:
# README Generator

  # Description

  Template which will allow the User to easily create a README document from the command line.

  # Table of Contents

  * [Installation](#installation)
  * [Usage](#usage)
  * [Contributing](#contributing)
  * [Questions](#questions)
  * [Tests](#tests)
  * [License](#license)

  ## Installation
  Node.js must be installed first. Once the file is open, open an integrated Terminal for index.js. Run node index.js in the command line.

  ## Usage
  Answer the questions in the command line to fill out your README template. Once completed, a README document will be generated to the utils folder.

  ## License
![https://choosealicense.com](https://shields.io/badge/license-MIT-green)
* https://choosealicense.com/licenses/mit/

  ## Contributing
  Contributions are welcome. Please email me with any suggestions. See contact details below.

  ## Tests
  Currently no tests.

  ## Questions
  If you have any questions, please contact me at<EMAIL_ADDRESS>
  You can also visit my [Github Page](https://github.com/jkelly101).


text:
# Speedster

A graphical UI for aria2, powered by Electron, React, Ant Design.

# Screenshots

![](./screenshots/1.jpg)
![](./screenshots/2.jpg)
![](./screenshots/3.jpg)

# Prerequisite

* [aria2](https://aria2.github.io/)

# Donate

I really appreciate that if you donate me and keep me up on this way.

* Bitcoin: `1FG8ga2M54WZ1JJFqdhntHp3Gr2wCf6xft`
* Ether: `0x33d0b9aD12703555f40f95AB439B43295CBCd685`
* Bitcoin Cash: `qzwxu6w85lf7egv55zy4sfgfslwmcuk8tu6xmvakm8`
* Stellar: `GALGOLSZEQTBECAM6YUI34RRF2YTGLYCOX7B4U2ADOETAIZB2EGZA4RN`

# LICENSE
MIT


text:
# Host Theme

Theme for [Orchard Core](https://github.com/orchardcms/OrchardCore) to be used on "Default" tenant within a multi-tenant website.

## Build Status

[![NuGet](https://img.shields.io/nuget/v/Etch.OrchardCore.HostTheme.svg)](https://www.nuget.org/packages/Etch.OrchardCore.HostTheme)

## Orchard Core Reference

This module is referencing a stable build of Orchard Core ([`1.6.0`](https://www.nuget.org/packages/OrchardCore.Module.Targets/1.6.0)).

## Installing

This module is available on [NuGet](https://www.nuget.org/packages/Etch.OrchardCore.HostTheme). Add a reference to your Orchard Core web project via the NuGet package manager. Search for "Etch.OrchardCore.HostTheme", ensuring include prereleases is checked.

Alternatively you can [download the source](https://github.com/etchuk/Etch.OrchardCore.HostTheme/archive/master.zip) or clone the repository to your local machine. Add the project to your solution that contains an Orchard Core project and add a reference to Etch.OrchardCore.HostTheme.

## Development

### Prerequisities

#### [.NET Core](https://docs.microsoft.com/en-us/dotnet/core/)

Orchard Core runs on the .NET Core. Download the latest version from [https://www.microsoft.com/net/download/core](https://www.microsoft.com/net/download/core).

#### [NodeJS](https://nodejs.org/en/)

The theme requires NodeJS to assist with gathering third party front-end dependencies and compiles front-end assets. Compilation of front-end assets is handled by [Webpack](https://webpack.js.org/).

### Pattern Library

The theme comes with a Fractal pattern library baked in. Head over to the [official Fractal website](https://fractal.build/) to learn more about working with Fractal. The [commands](/#commands) used when developing on the theme are geared to encouraging development through with the pattern library. The pattern library will be included in the theme package, which makes it accessible when referenced within an Orchard Core project. While your Orchard Core site is running navigate to `/Etch.OrchardCore.HostTheme/patterns/index.html` to view the pattern library.

### Commands

#### Developing

When developing on the theme it's likely you're be working with HTML and static assets (CSS & JavaScript). To assist with building the theme and provide a resource to content managers the theme comes with a pattern library. Running the command below will set up compilation of front end assets and spin up a web server for viewing the pattern library in your web browser.

    npm run start

#### Compiling Front-end Assets

When developing, it's likely you'll be working with front-end assets (located in `/Assets`) that need to be compiled in to files that are referenced by the theme (in `Views/Layout.cshtml`). The command shown below will compile CSS & JavaScript assets via Webpack and keep watch of files that will trigger compilation.

    npm run bundle:watch

_Hint: Running `npm start` will run the command above after running `npm install`._

When the theme is deployed to a production environment we need to serve compressed assets for optimial delivery to improve page load times. The command below will compile assets ready for optimal delivery. This command ia automatically run when the project is compiled with `--configuration Release`.

    npm run bundle:prod

#### Launching Pattern Library

To spin up a web server (seperate from an Orchard Core site) that'll provide access to the pattern library run the command below. Any changes to theme assets will automatically be reflected in the pattern library. Once the command below has been run, navigate to `http://localhost:3000` to view the pattern library.

    npm run start:patterns

_Hint: Running `npm start` will run the command above after running `npm install`._

#### Packaging

When the theme is compiled (using `dotnet build`) it's configured to generate a `.nupkg` file (this can be found in `\bin\Debug\` or `\bin\Release`).

gha_language: SCSS


text:
![Image of QuDexPay](src/qt/res/icons/bitcoin.png)
LPA is a coin for secret dating that has feature darksend, masternode for supporting private meet up.

Anonymized transactions using coin mixing technology. 1-Second-Transactions. Network stability with masternodes, each is secured with a collateral of 10.000 LPA. 100% Governance.

# Coin Specs

• PoW Algorithm: Quark

• Premine: (#1 Block) 410,000 LPA (14% of PoW) For 10 masternodes to build secret dating site's darksend feature, dating site referal bonus.

• PoW Blocks: 2 - 1051200

• PoS Blocks: Starting from 1051200

• Block Time: 60 Seconds

• PoW Max Coin Output/Supply: 6,991,840

• PoW Ending: ~ ca. 730 Days (Estimated: 12/2020)

• Masternode Requirements: 10,000 LPA

• Maturity: 120 Confirmations

• Prefix: LPA adresses start with the capital letter "L"

# PoW Reward Distribution

_Proof of Work block rewards, masternode reward allocation starting at the 10th November 2017_

Block Height	Reward Amount	Masternodes	Miners

Block 2 - 52560	10 LPA	   Masternodes 20%	Miners 80%

Block 52561 - 525600	7 LPA	  Masternodes 30%	Miners 75%

Block 525601 - 1051200	5 LPA	  Masternodes 40%	Miners 70%

Masternode and staker rewards with PoS:
Masternodes and stakers will receive split reward allocation when PoS sets in.
This means the more masternodes are in the system, the more staking gets attractive and vice versa.

# PoS Block Rewards

_Proof of Stake will automatically be enabled at block 1051200._

Block Height	Reward Amount

Block 1051200 - 1576800	5 LPA

Block 1576801 - 2102400	3 LPA

Block 2102401 - infinite	1 LPA

repository: forkee/lpacoin

repo_name: forkee/lpacoin


text:
# Gesture-driven-Smart-Home
Using your hand gestures, you can play/pause video or you can switch on/off a light.This code can be modified to control other household appliances as well such as fans and other smart home devices.

Steps to run the code:-

For Video.py:

    Download the source code.
    Run directly on any python ide.

For Light.py:

    Download the source code.
    You can run it on any python ide. But for this you need an wifi/hotspot chip to connect to your light. The above code is based on both Image Processing and IOT.