text:
# Battleship

This is a recreation of the classic Battleship board game. You can play a live version at https://battleship.rankoliang.com/

The major libraries and frameworks used in this app are:

- React
- Redux
- Jest

## Getting Started

Run `yarn install` to install all of the dependencies.

To start developing locally,

```
yarn start
```

to run the development server.

Run `yarn build` to create a production ready build.

## Rules

Users will place 5 different ships when the game starts. These include:

- Carrier: length 5
- Battleship: length 4
- Cruiser: length 3
- Submarine: length 3
- Destroyer: length 2

Afterwards, the player and the ai will take turns attacking each other's boards.
Players will be informed that a ship is hit or sunken. The first player to sink all ships wins.

There are 6 different variations of difficulties of ai in this game.

## Future Improvements

- The slices can be improved by further normalizing the data in the store, especially the board slice
  - This can be done potentially using the Redux-ORM or the Normalizr library
- A better ai using a probability density function can be implemented
- Add the ability to play against another player locally or on the web

repository: rankoliang/battleship

repo_name: rankoliang/battleship


text:
# RevNet with TensorFlow eager execution

This folder contains an TensorFlow eager implementation of the [Reversible Residual Network](https://arxiv.org/pdf/1707.04585.pdf) adapted from the released implementation by the authors. The presented implementation can be ran both in eager and graph mode. The code is considerably simplified with `tf.GradientTape`. Moreover, we reduce the step of reconstructing the outputs. This saves us from using `tf.stop_gradient` and makes the model run faster.

##  Content

- `revnet.py`: The RevNet model.
- `blocks.py`: The relevant reversible blocks.
- `cifar_tfrecords.py`: Script to generate the TFRecords for both CIFAR-10 and CIFAR-100.
- `cifar_input.py`: Script to read from TFRecords and generate dataset objects with the `tf.data` API.
- `config.py`: Configuration file for network architectures and training hyperparameters.
- `main.py`: Main training and evaluation script.
- `ops.py`: Auxiliary downsampling operation.

## To run
- Make sure you have installed TensorFlow 1.9+ or the latest `tf-nightly`
or `tf-nightly-gpu` pip package in order to access the eager execution feature.

- First run

```bash
python cifar_tfrecords.py --data_dir ${PWD}/cifar
```
to download the cifar dataset and convert them
to TFRecords. This produces TFRecord files for both CIFAR-10 and CIFAR-100.

- To train a model run

```bash
python main.py --data_dir ${PWD}/cifar
```

- Optional arguments for `main.py` include
  - `train_dir`: Directory to store eventfiles and checkpoints.
  - `restore`: Restore the latest checkpoint.
  - `validate`: Use validation set for training monitoring.
  - `manual_grad`: Use the manually defined gradient map given by the authors.
  - `dataset`: Use either `cifar-10` or `cifar-100`

## Performance
- With the current implementation, RevNet-38 achieves >92% on CIFAR-10 and >71% on CIFAR-100.

## Reference
The Reversible Residual Network: Backpropagation Without Storing Activations.
Aidan N. Gomez, Mengye Ren, Raquel Urtasun, Roger B. Grosse. Neural Information Processing Systems (NIPS), 2017.

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# **The Best Ionic v1.x chat template**

*Ionic Magic Chat with Angular Elastic, Autolinker.js and more!*

# Demo

Do you want to see this chat in action? Visit https://jdnichollsc.github.io/Ionic-ElastiChat-with-Images yay!
> Automatically deployed to GitHub Pages using Gulp - Check the **last task** into [gulpfile.js](https://github.com/jdnichollsc/Ionic-Starter-Template/blob/master/gulpfile.js)

* Preview the app using **[Ionic View App](http://view.ionic.io/)** with the ID: 8a460031

# Instructions

1. Download this template.
2. Execute the command `npm install`
3. Execute the command `gulp`
4. Run Ionic:
   - `ionic serve` to test on the browser **(Gulp is running by default)**.
   - `ionic run android --livereload` to test on the device.

### **Note**: This project structure is based on my free **[Ionic Starter Template](http://market.ionic.io/starters/ionic-starter-template)**, you can migrate any Ionic 1.x project to this template to use Gulp in the best way.

# Other Projects
- **[PokéDex GO - Community](https://github.com/proyecto26/PokeDex-GO)**
- **[Ionic Starter Template](http://market.ionic.io/starters/ionic-starter-template)**
- **[IonPhaser](http://market.ionic.io/plugins/ionphaser)**
- **[Ionic Drag and Drop](https://github.com/jdnichollsc/Ionic-Drag-and-Drop)**
- **[Game of Drones](https://github.com/jdnichollsc/Game-of-Drones)**

# Collaborators
* [nadeemkhan](https://github.com/nadeemkhan) - **Nadeem Khan**<EMAIL_ADDRESS>* [jdnichollsc](https://github.com/jdnichollsc) - **Juan David Nicholls**<EMAIL_ADDRESS>
# Credits
- Ross: https://codepen.io/rossmartin/pen/XJmpQr
- https://forum.ionicframework.com/t/ionic-elastichat-chat-demo-w-auto-resizing-textarea/13562

# Supporting
I believe in Unicorns 🦄
Support [me](http://www.paypal.me/jdnichollsc/2), if you do too.

Donate **Ethereum**, **ADA**, **BNB**, **SHIBA**, **USDT**, **DOGE**:

![Wallet address](https://user-images.githubusercontent.com/2154886/123501719-84bf1900-d60c-11eb-882c-98a499cea323.png)

> Wallet address: 0x3F9fA8021B43ACe578C2352861Cf335449F33427

Please let me know your contributions! 🙏

# Happy coding
Made with <3

license: MIT

gha_language: JavaScript


text:
# chili-time
Pulls down Guckenheimer's menu for Union Pacific Center and tells me when there's chili.

If you're interested in knowing when there's chili in the Union Pacific cafeteria, you can simply add the URL to your calendar.

In Google Calendar, just go to Other Calendars and then **Add by URL**.

![Google Calendar - Add Calendar by URL](https://github.com/bdetweiler/chili-time/blob/master/googlecalendar.png "Google Calendar - Add Calendar by URL")

Enter the following URL: [http://bdetweiler.github.io/projects/chilitime/chilitime.ics](http://bdetweiler.github.io/projects/chilitime/chilitime.ics)

# Frequently Asked Questions

## Q. Why did you write this? Why don't you just look at their website?
What, pull up the website every day like some commoner? Psht. I didn't go through 8 years of computer science school to look at websites all day. \*scrolls listlessly through Facebook\*

## Q. Would you consider expanding this to other cafeterias?
If I ever work somewhere else, I will address the situation at that time.

## Q. What about other foods?
Sorry, I am only passionate about chili.

repository: bdetweiler/chili-time

repo_name: bdetweiler/chili-time


text:
# simple-app

######These steps are required before you can to run the project in browser:
  - Install last [node.js]  for your platform (for Mac OS use brew - brew install nodejs)
  - Checkout last version from [repository]
  - Go to client root folder that include *(./public, ./app)* folders
  - Please type in console/terminal command ``` npm install ```
  - Install [bower.js] with npm ```npm install bower -g ```
  - Please type in console/terminal command ```bower install```
  - Please type in console/terminl command ```npm install -g json-server```
  - Run json-server ```json-server --watch db.json```
  - Run web-dev-server ```npm run http:dev:watch```
  - Open URL http://localhost:8080 in your browser

repository: yugrinkov/simple-app

repo_name: yugrinkov/simple-app


text:
<img width="130px" src="https://raw.githubusercontent.com/actyx-contrib/react-pond/master/icon.png?token=AATHWQIC5RWS62GY3OINH3C645MHQ">

# React-Pond

Use the [Actyx Pond framework](https://developer.actyx.com/docs/pond/getting-started/) fully integrated into React. Expand your toolchain with `<Pond>`, `useFish`, and `usePond` to speed up your UI projects and write distributed apps in a couple of hours.

## 📦 Installation

React-Pond is available as a [npm package](https://www.npmjs.com/package/@actyx-contrib/react-pond).

```shell
npm install @actyx-contrib/react-pond
```

# 📖 Documentation and detailed examples

You can access the full API documentation and related examples by visiting: [https://actyx-contrib.github.io/react-pond](https://actyx-contrib.github.io/react-pond/)

You will find detailed examples [here](https://github.com/actyx-contrib/react-pond/tree/master/example). They can be executed running e.g. `npm run example:chatRoom'.

# 🤓 Quick start

## 🌊 `<Pond>...</Pond>`

Wrap your application with the `<Pond>` to use you fish everywhere in the code.

### Example

```js
ReactDOM.render(
  <Pond
    manifest={{
      appId: 'com.example.react-pond-example',
      displayName: 'React Pond Example',
      version: '0.0.1'
    }}
    onError={() => {
      setTimeout(() => location.reload(), 5000)
      return <div>Connection to Actyx rejected: {JSON.stringify(e)}. Next reconnect in 5 seconds.</div>
    }}
  >
    <AmazingDistributedApp />
  </Pond>,
  document.getElementById('root')!,
)
```

## 🐟 `useFish` and `useFishFn`

Write your distributed logic with the well-known fish and get the state as easy as possible.

- `useFish(fish)`: Hydrate one explicit fish without a factory
- `useFishFn(fishFactory, properties)`: Use a factory function to hydrate fish with properties

### 📖 Example

```js
const MaterialRequest = ({ id }: Props) => {
  const allOpenMatReq = useFish(MatRequest.allOpen)
  const matReq = useFishFn(MatRequest.of, id)

  return (
    <div>
      <div>Open Material Requests: {allOpenMatReq.ids.length}</div>
      <div>
        Material Request ({id}): {matReq.state.status}
      </div>
      <button
        onClick={() =>
          matReq.run((_state, enqueue) => enqueue(Tag('material').withId(id), EventType.Done))
        }
      >
        Done
      </button>
    </div>
  )
}
```

## 🎏 `useRegistryFish`

Map your registry fish to the entities and create tables, lists, complex autocomplete fields, ...

### 📖 Example

```js
const MaterialRequests = () => {
  const allOpenMatReq = useRegistryFish(MatRequest.allOpen, reg => reg.ids, MatRequestFish.of)

  const done = (matReq: ReactFish<State, Events, string>) => {
    matReq.run((_state, enqueue) => enqueue(Tag('material').withId(matReq.props), EventType.Done))
  }

  return (
    <div>
      <div>Open Material Requests: {allOpenMatReq.length}</div>
      {allOpenMatReq.map(matReq => (
        <div key={matReq.props}>
          <div>
            {matReq.props}: {matReq.state.status}
          </div>
          <button onClick={() => done(matReq)}>Done</button>
        </div>
      ))}
    </div>
  )
}
```

## 🌊 `usePond`

The pond is not hidden from you. Use it as usual with `const pond = usePond()`.

### 📖 Example

```js
export const App = () => {
  const pond = usePond()
  const { info, getPondState } = pond
  const [pondState, setPondState] = React.useState<PondState>()
  React.useEffect(() => {
    getPondState(setPondState)
  }, [])

  return (
    <div>
      <hr />
      <h3>Pond State</h3>
      <pre>{JSON.stringify(pondState, undefined, 2)}</pre>
      <hr />
      <h3>Pond Info</h3>
      <pre>{JSON.stringify(info(), undefined, 2)}</pre>
    </div>
  )
}
```


text:
# This is heavly work in progress!
## Apollo-link-algolia
apollo-link-algolia provides you a simple way to query Algolia in graphQL with [Apollo-client](https://www.apollographql.com/client/) **without building a graphQL server**

### Example
```js
const LOCATIONS_QUERY = gql`
  query LocationsQuery {
    locationsInRadius @algolia(index: "dev_LOCATIONS", aroundLatLng: "40.71, -74.01", aroundRadius: 1000)
  }
`
```

repository: absolvent/apollo-link-algolia

gha_license_id: MIT

repo_name: absolvent/apollo-link-algolia


text:
---
title: "Characteristics of Huge Pages"
date: 2019-07-29T17:09:36-07:00
draft: true
---

This post is more like a cheat sheet for huge pages, some details need to be updated later.

The virtual-to-physical address translation overhead,a major performance bottleneck for modern workloads, can be effectively alleviated with huge pages. [^1]

The page size in modern operation system is 4KiB, which is considered too small for large memory workloads.

Using huge pages can minimize CPU time spent in performing page table lookups by reducing TLB misses.[^2] [^4]

![huge table](/img/huge-page.png)

### Huge page sizes

2MiB (likely) or/and 1GiB, AFAIK, no other options.

### Hardware support

Huge page needs hardware support, however, it has been implemented for decades, in other words, it's supported in most x86 CPUs.

### Huge page features

1. Huge pages will never be swapped out.

2. The memory reserved by huge pages can only be utilized by processes that are huge page aware.

3. Huge pages are pre-allocated/reserved on system boot, they cannot be used for other purpose(e.g. convert to normal pages).

### Huge page vs Transparent Huge Page (THP)

They are different things, though people often confuses these two (even in some peer-reviewed academic papers[^1])

>Huge pages can be difficult to manage manually, and often require significant changes to code in order to be used effectively. As such, Red Hat Enterprise Linux 6 also implemented the use of transparent huge pages (THP). THP is an abstraction layer that automates most aspects of creating, managing, and using huge pages. [^3]

### Problems with THP

It dynamically allocates huge page from heap, which may cause extra memory movement due to memory fragmentation, thus cause very high latency on page fault.

(To make things worse, some kernel pages are unmovable thus pollutes the contiguous physical memory [^1] [^4])

>THP hides much of the complexity in using huge pages from system administrators and developers.
>As the goal of THP is improving performance, its developers (both from the community and Red Hat) have tested and optimized THP across a wide range of systems,
>configurations, applications, and workloads. This allows the default settings of THP to improve the performance of most system configurations.
>**However, THP is not recommended for database workloads.**[^3]

### My words

We (high performance systems) should always use huge pages when possible.

Page table is evil, we should (eventually) get rid of it, and huge page is the first step.

Modern kernel should have a "direct mode", in which applications ask for memory on startup and then have direct access to physical address (instead of traversing multiple page tables on every dereference).

[^1]: Making Huge Pages Actually Useful

[^2]: Efficient virtual memory for big memory servers

[^3]: [HUGE PAGES AND TRANSPARENT HUGE PAGES](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/performance_tuning_guide/s-memory-transhuge)

[^4]: Coordinated and Efficient Huge Page Management with Ingens

{{ template "_internal/disqus.html" . }}


text:
---
title: verifiergui.exe | Driver Verifier Manager
excerpt: What is verifiergui.exe?
---

# verifiergui.exe

* File Path: `C:\Windows\SysWOW64\verifiergui.exe`
* Description: Driver Verifier Manager

## Hashes

Type | Hash
-- | --
MD5 | `4DC139CE2F54F89EF5876272DC590D3C`
SHA1 | `09A16471B95429E8775E8EC900D97AF105D59D26`
SHA256 | `E1BDA156B07B827FEBA54BB2C0341F5678886B70EA463F06D2AE1A162CA585AC`
SHA384 | `30D5DA54EB25B58255BA71BFBD4B31A26C65858F93ED591804535879871AC6FFB48923CBBDA221A87BBA04103BAA1C9F`
SHA512 | `0C6403606D7A167085A9BE783D72F634B331D8DD36D75CBE5386A690AB4D2B18932448C0B103F0C98CD140FC81A4925355A49A1BF2E65401CE58F9F02122C572`
SSDEEP | `3072:6X2X3Xv22pr9X/XDoXdBewFXyEXm6XVvXQRjXwcJVIZen+Vcv2JBwwRBkBnRzePp:qGnjvsD5T5QpZfSwnR12q7USGMFR6t`

## Runtime Data

### Usage (stdout):
```cmhg

Copyright (c) Microsoft Corporation. All rights reserved.

COMMON USAGE:
  verifier /?
  verifier /standard /all
  verifier /standard /driver NAME [NAME ...]
  verifier /flags FLAGS /all
  verifier /flags FLAGS /driver NAME [NAME ...]
  verifier /rules [OPTION ...]
  verifier /query
  verifier /querysettings
  verifier /bootmode [persistent|resetonbootfail|oneboot]
  verifier /reset
  verifier /faults [PROB [TAGS [APPS [MINS]]]]
  verifier /faultssystematic [OPTION ...]
  verifier /log LOG_FILE_NAME [/interval SECONDS]
  verifier /volatile /flags FLAGS
  verifier /volatile /adddriver NAME [NAME ...]
  verifier /volatile /removedriver NAME [NAME ...]
  verifier /volatile /faults [PROB [TAGS [APPS [MINS]]]]

/?
  This help.

/standard
  Enable the Driver Verifier standard flags.
  This is functionally equivalent to '/flags 0x209BB'

/all
  Enable Driver Verifier on all drivers in a system.

/driver NAME [NAME ...]
  Specify the driver or list of drivers that should be verified.
  NAME is the name and extension of the file to verify (example: driver.sys).
  To enable Driver Verifier on more than one driver, list all drivers using a
  space separated list.  Wildcard values (such as n*.sys) are not supported.

/flags FLAGS
  Specify which options are enabled for verification.
  FLAGS value must be a number in decimal or hex (with 0x prefix).
  Note: Flags are applied to all drivers being checked by Driver Verifier.

  STANDARD FLAGS:
  These flags are considered standard options for Driver Verifier and can be
  set using '/standard' or by the combination of the options: '/flags 0x209BB'
    bit  0 (0x00000001) - Special pool
    bit  1 (0x00000002) - Force IRQL checking
    bit  3 (0x00000008) - Pool tracking
    bit  4 (0x00000010) - I/O verification
    bit  5 (0x00000020) - Deadlock detection
    bit  7 (0x00000080) - DMA checking
    bit  8 (0x00000100) - Security checks
    bit 11 (0x00000800) - Miscellaneous checks
    bit 17 (0x00020000) - DDI compliance checking

  ADDITIONAL FLAGS:
  These flags are designed for specific scenario testing.
  Flags marked with a (*) require I/O Verification (bit 4) also be enabled.
  Flags marked with a (**) support disabling of individual rules.
    bit  2 (0x00000004) - Randomized low resources simulation
    bit  9 (0x00000200) - Force pending I/O requests (*)
    bit 10 (0x00000400) - IRP logging (*)
    bit 13 (0x00002000) - Invariant MDL checking for stack (*)
    bit 14 (0x00004000) - Invariant MDL checking for driver (*)
    bit 15 (0x00008000) - Power framework delay fuzzing
    bit 16 (0x00010000) - Port/miniport interface checking
    bit 18 (0x00040000) - Systematic low resources simulation
    bit 19 (0x00080000) - DDI compliance checking (additional)
    bit 21 (0x00200000) - NDIS/WIFI verification (**)
    bit 23 (0x00800000) - Kernel synchronization delay fuzzing
    bit 24 (0x01000000) - VM switch verification
    bit 25 (0x02000000) - Code integrity checks

/rules [OPTION ...]
  Options for rules that can be disabled (advanced).
  query:      shows current status of controllable rules.
  reset:      resets all rules to their default state.
  default ID: sets rule ID to its default state.
  disable ID: disables specified rule ID.

/query
  Display a summary of Driver Verifier's current activity.

/querysettings
  Display a summary of the options and drivers that are currently enabled,
  or options and drivers that will be verified after the next boot.  The
  display does not include drivers and options added using /volatile.

/bootmode
  Sets the verifier boot mode.  Requires reboot to take effect.
  persistent:      Ensures that DV settings are persistent over many reboots.
                   This is default.
  resetonbootfail: If OS fails to boot, reset verifier for subsequent boots.
  oneboot:         Only enable verifier for next boot.

/reset
  Clear Driver Verifier flag and driver settings. Does not clear bootmode.
  Requires reboot to take effect.

/faults [PROB [TAGS [APPS [MINS]]]]
  Enable the Randomized low resources simulation bit and optionally control
  parameters for the Randomized low resources simulation.
  PROB: A number between 1 and 10000 specifying the fault injection
        probability. If this parameter is not specified, then the default
        value of 600 (6%) will be used.
  TAGS: A space separated list of the pool tags to be injected with faults.
        If this parameter is not specified, then any pool allocation can be
        injected with faults.
  APPS: A space separated list of the image filename of the applications that
        will be injected with faults. If this parameter is not specified then
        the Randomized low resources simulation can take place in any
        application.
  MINS: A positive number indicating the of minutes after rebooting during
        which no fault injection will occur. If this parameter is not
        specified, then the default length of 8 minutes will be used.

/faultssystematic [OPTION ...]
  Options for controlling the Systematic low resources simulation.
  enableboottime:       enables fault injections across reboots.
  disableboottime:      disables fault injections across reboots (default).
  recordboottime:       enables fault injections in 'what if' mode across
                        reboots.
  resetboottime:        disables fault injections across reboots and clears
                        the stack exclusion list.
  enableruntime:        dynamically enables fault injections.
  disableruntime:       dynamically disables fault injections.
  recordruntime:        dynamically enables fault injections in 'what if'
                        mode.
  resetruntime:         dynamically disables fault injections and clears the
                        previosly faulted stack list.
  querystatistics:      shows the current fault injection statistics.
  incrementcounter:     increments the test pass counter used to identify
                        when a fault was injected.
  getstackid COUNTER:   retrieves the indicated injected stack id.
  excludestack STACKID: excludes the stack from fault injection.

/log LOG_FILE_NAME [/interval SECONDS]
  Create a log file with the name LOG_FILE_NAME.
  If '/interval' option is not specified, the default 30 seconds is used.
  Note: If a 'verifier /log' command is typed at the command line, the command
  prompt does not return. Use CTRL+C to close the log and return.

/volatile
  Change the verifier settings dynamically without rebooting the system.
  Volatile settings are in effect until the next system reboot.

/volatile /adddriver NAME [NAME ...]
  Add the specified driver or drivers to the list of drivers that will be
  checked with volatile settings.

/volatile /removedriver NAME [NAME ...]
  Remove the specified driver or drivers from the list of drivers that are
  being checked with volatile settings.

```

## Signature

* Status: Signature verified.
* Serial: `33000000BCE120FDD27CC8EE930000000000BC`
* Thumbprint: `E85459B23C232DB3CB94C7A56D47678F58E8E51E`
* Issuer: CN=Microsoft Windows Production PCA 2011, O=Microsoft Corporation, L=Redmond, S=Washington, C=US
* Subject: CN=Microsoft Windows, O=Microsoft Corporation, L=Redmond, S=Washington, C=US

## File Metadata

* Original Filename: verifiergui.exe.mui
* Product Name: Microsoft Windows Operating System
* Company Name: Microsoft Corporation
* File Version: 10.0.14393.0 (rs1_release.160715-1616)
* Product Version: 10.0.14393.0
* Language: English (United States)
* Legal Copyright:  Microsoft Corporation. All rights reserved.

## File Similarity (ssdeep match)

File | Score
-- | --
[C:\WINDOWS\SysWOW64\verifiergui.exe](verifiergui.exe-1FFDE5339B78158668EDF02922258208.md) | 40
[C:\Windows\SysWOW64\verifiergui.exe](verifiergui.exe-56D77A92B6AFACDE189C0A5613A0F6CA.md) | 40
[C:\WINDOWS\SysWOW64\verifiergui.exe](verifiergui.exe-C52445F1AD490322ADC5D1AC5EFEEA61.md) | 38
[C:\Windows\SysWOW64\verifiergui.exe](verifiergui.exe-F61085E8A94C91AE6FF47F0D6FF449AF.md) | 38

MIT License. Copyright (c) 2020-2021 Strontic.


text:
---
title: "Pine64 + - Lollipop OS Install and Launch"
date: "2016-03-18"
---

The Pine 64 is here. I separately  purchased a Sandisk 64 gb Micro SD. To load and boot I used Phoenix Card and the Android Lollipop image, both from the [Acorn Wiki ](http://wiki.pine64.org/index.php/Pine_A64_Software_Release). In Phoenix Card I selected "Startup!" instead of "Product" or "Burn Key". It paused for a few moments halfway through writing and then finished off successfully. I used an android phone cable to a USB wall charge plugged into a power strip. I saw a tip about leaving the keyboard and mouse unplugged for initial boot. So did that as well.

First boot left me on the Pine 64 screen. (expected). Let it sit for 5 minutes or so. Then booted again and it's been running great. Updated Google Play and then installed and ran netflix as a test. High quality video. I did all of this from the wifi. Good download speeds, upload was not great, via speedtest app.

\[gallery ids="1181,1176,1177,1178,1180" columns="2" link="file" size="medium"\]

repository: NickFoden/nickfoden

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: NickFoden/nickfoden


text:
---
title: The Art of Continuous Cleansing in DevOps
tags: [DevOps]
style:
color:
description: >-
  First step in DevOps journey is to identify the "Waste" and have continuous
  cleansing process to remove the non value added efforts. Organization emerge
  successfully as sculpture reveal the idol from a raw stone by remove the
  unwanted scraps.
---

## The Art of Continuous Cleansing

A few months back I happened to travel in a bus with a Vedic scholar down south India. He was an energetic and enthusiastic personality in his late 40’s and his eyes seemed to have a positive outlook at life. Among many other topics that we discussed, one was about Veda’s insistence on purification of mind and body on daily basis. He verbalized some hymns almost for 2 hours. Most of them were quite intense to me, but the following point struck me.

> *By very nature we accumulate dirt or junk both physically and mentally. Vedas focus on how to clean and remove waste on day to day basis. We end up having health issues if the dirt is not removed continuously.*

I started contemplating on this that night. I felt this is quite applicable both in life and at work and is fundamental for the DevOps journey.

*As we build software, we accumulate dirt in the form of cultural and technical debt that do not bring value to both the organizations and clients. The unfortunate part is that it gets added, like fat in our body, without notice. One fine day you feel heavy to sprint. ****How can we cleanse on continuous basis?***

## Value Stream Mapping as a Cleansing Tool

Few weeks back I was consulting with an American Fortune 500 company which was adopting DevOps. My first step was to understand the current state of IT Value Stream. Most of the participants were new to Lean and Value Stream Mapping. Initially, for the participants, I presented the concept of “What is Value stream mapping and how it is relevant to DevOps?”

As the session started, I said, "I'm here with you to cleanse". Participants threw me a doubtful grin. I continued, "for the next two days you will be identifying the waste that impedes you to add value to your customer." Participants was skeptical about my approach, but gave their 100% to build the IT value stream.

For Two days, the exercise was very intense and interesting. Our first “Ah ha” moment came, when the team visualized the Value add efficiency and type of wastes that are slowing them down. For instance, Inventory (partial work done), was one of the major challenges. They maintained around 450 items in the form of change request, features, and defects starting from 2014. It was a herculean task for the product team to track, prioritize, check if they are duplicates and then document them. Team had a huge relief they cleansed irrelevant tickets and brought the backlog down to less than 100.

### Other techniques for continuous cleansing

* ·     **Daily Stand-up** –  daily ritual to recognize the non-value add activities that impedes the team to progress
* ·     **Sprint Retrospective** – Bi-weekly ritual to cleanse the unhealthy habits in the team
* ·     **Three Ways of the Phoenix project** – Continuous flow, feedback and improvement ideology to recognize the non-value add processes and work daily to cleanse them


text:
# workout-tracker

## User Story

* As a user, I want to be able to view create and track daily workouts. I want to be able to log multiple exercises in a workout on a given day. I should also be able to track the name, type, weight, sets, reps, and duration of exercise. If the exercise is a cardio exercise, I should be able to track my distance traveled.

## Business Context

A consumer will reach their fitness goals more quickly when they track their workout progress.

## Acceptance Criteria

When the user loads the page, they should be given the option to create a new workout or continue with their last workout.

The user should be able to:

  * Add exercises to the most recent workout plan.

  * Add new exercises to a new workout plan.

  * View the combined weight of multiple exercises from the past seven workouts on the `stats` page.

  * View the total duration of each workout from the past seven workouts on the `stats` page.

> **Important:** Look into using a MongoDB aggregate function to dynamically add up and return the total duration for each workout. Check out the [MongoDB documentation on the $addFields](https://docs.mongodb.com/manual/reference/operator/aggregation/addFields/), the [MongoDB documentation on the $sum operator](https://docs.mongodb.com/manual/reference/operator/aggregation/sum/), and the [Mongoose documentation on aggregate functions](https://mongoosejs.com/docs/api.html#aggregate_Aggregate) to learn how it can be accomplished.

To deploy an application with a MongoDB database to Heroku, you'll need to set up a MongoDB Atlas account and connect a database from there to your application. Be sure to use the following guides for support:

  * [Set Up MongoDB Atlas](../04-Important/MongoAtlas-Setup.md)

  * [Deploy with Heroku and MongoDB Atlas](../04-Important/MongoAtlas-Deploy.md)

## LINKS

Repository Link: https://github.com/saidmg/workout-tracker
Deployed Link  : https://your-daily-workout-tracker.herokuapp.com/

## ScreenShots

![tracker](https://user-images.githubusercontent.com/71358869/111379729-d6edb700-8679-11eb-8d76-cc30e70883f7.JPG)
![dashboard](https://user-images.githubusercontent.com/71358869/111379734-d81ee400-8679-11eb-8b09-b58fc617ea3f.JPG)

## License

Copyright <2021> <Said Mghabghab>

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

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

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

repository: saidmg/workout-tracker

repo_name: saidmg/workout-tracker


text:
# resize-magnetic-ebs-volume

This script "resizes" an AWS EBS volume by performing the following actions:
  1. detaching the volume from the a stopped instance
  2. creating a snapshot from that volume
  3. creating a bigger volume from that snapshot (in the same availability zone)
  4. attaching the new volume to the instance (in the same device location)

It must be used pointing to an instance that is:
  - in a 'stopped' state
  - backed by a single EBS volume of standard (AKA magnetic) type

It does not:
  - start/stop or modify any instance
  - delete anything (e.g. the old volume)
  - try to kill you

It also expects AWS credentials to be loaded in the environment.

## Why only magnetic?

Technically, it does work for volumes of any type, but so does modifying the volumes themselves for types other than `standard`, so that could be the preferred approach. This was just written to solve a specific problem.

If you really want to use it for volumes of any type, you can comment the line where it checks the volume type [here](https://gist.github.com/rodolfo42/86e158547683c60df0dfdd3f689bc1b0#file-resize-magnetic-ebs-volume-L120).

## Usage

After cloning/downloading it:

```shell
yarn # or npm install
./resize-magnetic-ebs-volume --instance-id INSTANCE_ID --to-size NEW_SIZE_GB [--region REGION]
```


text:
---
layout: post
title: Migrating to GitHub pages
---

This blog was initially hosted on a raspberry pi running Arch Linux. I was planning to run it on a virtual server as I am not allowed to host a website over a private IP address (Vodafone you s***). Github pages is a great option for me. They use jekyll too so I can migrate without any hassle! I deleted the record for `blog.xvzf.tech` and replaced it by a CNAME record pointing to `xvzf.github.io
`. Next, I had to modify the GitHub pages settings to enable my custom domain.

![GitHub Pages Settings](http://blog.xvzf.tech/public/images/github_pages_settings.png "GitHub Pages Settings")

Unfortunately GitHub pages won’t provide a valid certificate. The common name (CN) field of the certificate contains the FQDN (full qualified domain name) of the GitHub pages provider server. In order to be a valid certificate, the CN has to be set to blog.xvzf.tech. Maybe they fix that in some time!

{% highlight BASH %}
Nmap scan report for blog.xvzf.tech (<IP_ADDRESS>)
Host is up (0.028s latency).
Other addresses for blog.xvzf.tech (not scanned): <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS>
Not shown: 998 filtered ports
PORT    STATE SERVICE        VERSION
80/tcp  open  http-proxy     Varnish
|_http-server-header: GitHub.com
|_http-title:           xvzf · prepend tar
443/tcp open  ssl/http-proxy Varnish
|_http-title:           xvzf · prepend tar
| ssl-cert: Subject: commonName=www.github.com/organizationName=Fastly, Inc./stateOrProvinceName=California/countryName=US
| Subject Alternative Name: DNS:www.github.com, DNS:*.github.com, DNS:github.com, DNS:*.github.io, DNS:github.io, DNS:*.githubusercontent.com, DNS:githubusercontent.com
| Not valid before: 2016-01-20T00:00:00
|_Not valid after:  2017-04-06T12:00:00
|_ssl-date: TLS randomness does not represent time
{% endhighlight %}

Everything seems to be working now! Free hosting! I am fine with that.


text:
# class-cache
Class Cache Tip For PHP

## Description
IF you get same multiple pieces of information during one process.
class-cache can cache that information in PHP internal memory.
It has advantage of saving memory, processing time, cpu power.

## Requirement
PHP 5.4 +

## Install
Download ClassCache.php file and require.
Extends ClassCache in target class that executes the acquisition process

## Usage
Check the sample scripts.
* ClassSample.php
* sample.php


text:
# 🏬 three-city 🏢
Testing the library three.js

![Screenshot](./docs/capture.png)

#### 🕹 Demo https://efrensanchez.github.io/three-city/

## ✋ Before Getting Started You Should…

    1. Have some JavaScript knowledge.
    2. Have some Three.js knowledge.

## ⭐ Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### 👉 Clone the repository to your machine

You can use git or download it directly from github

![](https://imgur.com/bpHE9K6.png)

### 👉 Open `index.html` in your browser

## 🏗 Built With

- [Three.js](https://threejs.org/) - The web library used

## 🖋 Author

- **Efren Sanchez** - *Initial work* - [EfrenSanchez](https://github.com/EfrenSanchez)

## © License

This project is licensed under the MIT License

repository: EfrenSanchez/three-city

repo_name: EfrenSanchez/three-city


text:
nodejs-dnsimple
===============

This is an unofficial [DNSimple](http://dnsimple.com/) API module for [Node.js](http://nodejs.org/).
You need a DNSimple account to use this.

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

The release on npm is the latest stable version:

	npm install dnsimple

The code on Github is the most recent version, but can be unstable:

	npm install git+https://github.com/fvdm/nodejs-dnsimple

Usage
-----

```js
var dnsimple = require('dnsimple')

dnsimple.api.email =<EMAIL_ADDRESS>dnsimple.api.token = 'your API token'

dnsimple.domains.add( 'example.tld', function( domain ) {
	console.log( domain.name +' created with ID '+ domain.id )
})
```

Authentication
--------------

The module supports both authentication by **email:token** and **email:password**.
The *token* is more secure as it can easily be reset in account at [dnsimple.com/account](https://dnsimple.com/account).
The password uses HTTP Basic Authentication.

### Token

```js
dnsimple.api.email =<EMAIL_ADDRESS>dnsimple.api.token = '12345abcde'
```

### Password

```js
dnsimple.api.email =<EMAIL_ADDRESS>dnsimple.api.password = 'secret'
```

Methods
-------

Each method takes a _callback function_ with two parameters: `err` and `data`.

When an error occurs `err` is an instance of `Error` and `data` is `null`. It can get a `.code` property if a HTTP error happened and a `.data` property
if the remote API returned something other than JSON data. It also has a `.stack` property to figure out where the error was triggered.

When everything looks alright `err` will be `null` and `data` will be the parsed JSON `object`.

Domains
-------

### domains.list ( simpleBool, callback )

List domainnames in your account.

**simpleBool** true

A simple *array* with domainnames.

```js
dnsimple.domains.list( true, console.log )

[ 'one.com',
  'two.net',
  'three.nl' ]
```

**simpleBool** false (default)

An object with domainnames details, the keys are their IDs.

```js
{ '123':
   { auto_renew: null,
     created_at: '2011-01-09T02:24:58Z',
     expires_at: null,
     id: 123,
     language: null,
     last_name_server_status_check: '2012-05-18T18:53:24Z',
     lockable: null,
     name: 'one.com',
     name_server_status: 'inactive',
     parsed_expiration_date: null,
     real_time: null,
     registrant_id: null,
     registration_status: 'hosted',
     state: 'hosted',
     token: 'Zp1J...',
     unicode_name: 'one.com',
     updated_at: '2012-05-18T18:53:24Z',
     use_route53: null,
     user_id: 121,
     uses_external_name_servers: null,
     record_count: 1,
     service_count: 0,
     'private_whois?': false }
}
```

### domains.findByRegex ( regexString, cb )

List only domains with names matching on regex.

```js
// All .com domains
dnsimple.domains.findByRegex( '\.com$', console.log )
```

### domains.show ( domainname, cb )

Get details about one domainname

```js
dnsimple.domains.show( 'one.com', console.log )
```

### domains.add ( domainname, cb )

Add a domain to your account

```js
dnsimple.domains.add( 'two.com', console.log )
```

### domains.delete ( domainname, cb )

Delete a domains and its DNS records from your account

```js
dnsimple.domains.delete( 'two.com', console.log )
```

Registration
------------

### domains.check ( domainname, cb )

Check domainname availability for registration or transfer to DNSimple.

```js
dnsimple.domains.check( 'frankl.in', console.log )
```

**Unavailable:**

```js
{ name: 'frankl.in',
  status: 'unavailable',
  price: '25.00',
  currency: 'USD',
  currency_symbol: '$',
  minimum_number_of_years: 1 }
```

**Available:**

```js
{ name: 'awesome-stuff.org',
  status: 'available',
  price: '14.00',
  currency: 'USD',
  currency_symbol: '$',
  minimum_number_of_years: 1 }
```

### domains.register ( domainname, registrantID, [extendedAttribute], cb )

Register a domainname at DNSimple. Your account will be charged on successful registration.

* **domainname** - *required* - the domain to register
* **registrantID** - *required* - the owner of the domain
* **extendedAttribute** - *optional* - extra fields for certain TLDs

```js
dnsimple.domains.register( 'example.tld', 1, console.log )
```

### domains.transfer ( domainname, registrantID, [authinfo], cb )

* **domainname** - *required* - the domain to transfer into your account
* **registrantID** - *required* - the new owner of the domain
* **authinfo** - *optional* - the auth-code required for some TLDs

```js
dnsimple.domains.transfer( 'example.tld', 1, 'abcdefg', console.log )
```

### domains.renew ( domainname, [whoisPrivacy], cb )

Renew a domainname registration for a new period.

* **domainname** - *required* - the domain to renew
* **whoisPrivacy** - *optional* - also renew whois privacy protection, true or false

```js
dnsimple.domains.renew( 'example.tld', true, console.log )
```

### domains.autorenew ( domainname, status, cb )

Enable or disable auto-renewal for a domainname.

* **domainname** - *required* - the domain to set the autorenew for
* **status** - *required* - enabled or disable autorenewal

```js
dnsimple.domains.autorenew( 'example.tld', true, console.log )
```

### domains.transferout ( domainname, cb )

Prepare a domain for transferring to another registrar.

```js
domains.transferout( 'example.tld', console.log )
```

### domains.nameservers ( domainname, nameservers, cb )

Set nameservers for a domain at the registry.

* **domainname** - *required* - the domain to set nameservers for
* **nameservers** - *required* - object with nameservers to set

```js
dnsimple.domains.nameservers(
	'example.tld',
	{
		ns1:	'ns1.company.tld',
		ns2:	'ns2.company.tld'
	},
	console.log
)
```

Services
--------

### domains.services.list ( domainname, cb )

List applied services (vendor presets) for a domain

```js
dnsimple.domains.services.list( 'one.com', console.log )
```

### domains.services.available ( domainname, cb )

List available services for a domain

```js
dnsimple.domains.services.available( 'one.com', console.log )
```

### domains.services.add ( domainname, serviceID, cb )

Apply a service to a domain

**serviceID** can be a service *numeric* ID or its *shortname*

```js
// Apply Heroku presets to one.com
dnsimple.domains.services.add( 'one.com', 'heroku', console.log )
```

### domains.services.delete ( domainname, serviceID, cb )

Remove a service from a domain

**serviceID** can be a service *numeric* ID or its *shortname*

```js
// Remove Heroku presets from one.com
dnsimple.domains.services.delete( 'one.com', 'heroku', console.log )
```

### domains.template ( domainname, templateID, cb )

Apply a template (custom presets) to a domain. This is an alias for *templates.apply*.

**serviceID** can be a service *numeric* ID or its *shortname*

```js
// Apply your office records to one.com
dnsimple.domains.template( 'one.com', 'office', console.log )
```

DNS
---

### dns.list ( domainname, cb )

List DNS records for a domain

```js
dnsimple.dns.list( 'one.com', console.log )
```

### dns.show ( domainname, recordID cb )

Get DNS record details for a *recordID* on *domainname*

```js
dnsimple.dns.show( 'one.com', 1234, console.log )
```

Returns an object with the record details:

```js
{ content: '<IP_ADDRESS>',
  created_at: '2011-03-31T01:21:08Z',
  domain_id: 123,
  domain_service_id: null,
  id: 1234,
  name: '',
  pdns_identifier: '112233',
  prio: null,
  record_type: 'A',
  special_type: null,
  ttl: 3600,
  updated_at: '2011-11-28T20:39:51Z' }
```

### dns.add ( domainname, recordObject, cb )

**Required:** name, record_type, content

**Optional:** ttl, prio

```js
dnsimple.dns.add(
	'one.com',
	{
		name:			'www',
		record_type:	'A',
		content:		'<IP_ADDRESS>'
	},
	console.log()
)
```

### dns.update ( domainname, recordID, cb )

Replace a record's details, same syntax as **dns.add**.

### dns.delete ( domainname, recordID, cb )

Delete a DNS record from a domain.

```js
dnsimple.dns.delete( 'one.com', 1234 )
```

Unlicense
---------

This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.

In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.

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

For more information, please refer to <http://unlicense.org/>

license: Unlicense

repository: FashGek/nodejs-dnsimple

repo_name: FashGek/nodejs-dnsimple


text:
# FAQ

## Retaining Client IPAddress

Please read [Retain Client IPAddress Guide here](./user-guide/retaining-client-ipaddress.md).

## Kubernetes v1.22 Migration

If you are using Ingress objects in your cluster (running Kubernetes older than v1.22), and you plan to upgrade your Kubernetes version to K8S 1.22 or above, then please read [the migration guide here](./user-guide/k8s-122-migration.md).

## Validation Of __`path`__

- For improving security and also following desired standards on Kubernetes API spec, the next release, scheduled for v1.8.0, will include a new & optional feature of validating the value for the key `ingress.spec.rules.http.paths.path` .

- This behavior will be disabled by default on the 1.8.0 release and enabled by default on the next breaking change release, set for 2.0.0.

- When "`ingress.spec.rules.http.pathType=Exact`" or "`pathType=Prefix`", this validation will limit the characters accepted on the field "`ingress.spec.rules.http.paths.path`",  to "`alphanumeric characters`", and  `"/," "_," "-."` Also, in this case, the path should start with `"/."`

- When the ingress resource path contains other characters (like on rewrite configurations), the pathType value should be "`ImplementationSpecific`".

- API Spec on pathType is documented [here](https://kubernetes.io/docs/concepts/services-networking/ingress/#path-types)

- When this option is enabled, the validation will happen on the Admission Webhook. So if any new ingress object contains characters other than  "`alphanumeric characters`", and  `"/," "_," "-."` , in the `path` field, but is not using `pathType` value as `ImplementationSpecific`, then the ingress object will be denied admission.

- The cluster admin should establish validation rules using mechanisms like "`Open Policy Agent`", to validate that only authorized users can use ImplementationSpecific pathType and that only the authorized characters can be used. [The configmap value is here](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/configmap/#strict-validate-path-type)

- A complete example of an Openpolicyagent gatekeeper rule is available [here](https://kubernetes.github.io/ingress-nginx/examples/openpolicyagent/)

- If you have any issues or concerns, please do one of the following:
  - Open a GitHub issue
  - Comment in our Dev Slack Channel
  - Open a thread in our Google Group<EMAIL_ADDRESS>

repository: kubernetes/ingress-nginx

gha_language: Go

repo_name: kubernetes/ingress-nginx


text:
# 02 - Quick start

## Use rebar3 and nova

Start by add the rebar3 template for Nova.

```bash
cd installer
./installer.sh
```

After this is done use rebar3 to generate a new project with Nova.

```bash
rebar3 new nova my_first_nova
```

```
$ rebar3 new nova my_first_app
===> Writing my_first_app/priv/my_first_app.routes.erl
===> Writing my_first_app/src/my_first_app.app.src
===> Writing my_first_app/src/my_first_app_app.erl
===> Writing my_first_app/src/my_first_app_sup.erl
===> Writing my_first_app/src/controllers/my_first_app_main_controller.erl
===> Writing my_first_app/src/views/my_first_app_main_controller.dtl
===> Writing my_first_app/rebar.config
```

This will create a bunch of boiler plate files that helps you getting started. To start your app just type

```
$ rebar3 shell
===> Verifying dependencies...
===> Compiling my_first_app
Erlang/OTP 20 [erts-9.3] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:0] [hipe] [kernel-poll:false]

Eshell V9.3  (abort with ^G)
1>
```

Now you can type `application:ensure_all_started(my_first_app).` to start your app. If you now open http://localhost:8081/ you should see a "Nova is running"-message.

## Dev mode

When developing you probably don't want to quit erlang, recompile and then re-run the whole thing again. If you specify `{dev_mode, true}` in your configuration the reloader will start.
This module checks for file changes and recompiles/reloades the files if needed.

repository: c-bik/nova

repo_name: c-bik/nova


text:
# application.skeleton
[![NPM version](https://badge.fury.io/js/application.skeleton.svg)](http://badge.fury.io/js/application.skeleton)
[![dependencies](https://david-dm.org/luscus/application.skeleton.svg)](https://david-dm.org/luscus/application.skeleton)
[![devDependency Status](https://david-dm.org/luscus/application.skeleton/dev-status.svg?theme=shields.io)](https://david-dm.org/luscus/application.skeleton#info=devDependencies)

Application Framework base package: it loads and applies packages to the application object.

I was and still am a big fan of LEGO® and I would like to think that software development should work in the same way.
[NPM](https://www.npmjs.com) is a great piece box and if we use prototype-less patterns (mixins, ...) we could apply behaviours to our applications
by expressing them as dependencies...

Example, my application should:

- emit events (install [application.mixin.emitter](https://github.com/luscus/application.mixin.emitter))
- be a state machine (install [application.mixin.automaton](https://github.com/luscus/application.mixin.automaton))
- use network communication (install [application.module.socket](https://github.com/luscus/application.module.socket) and any available protocol package)

This way I don't need to implement all this stuff or write code to use libraries: the behaviour is instantly available in the application object.
I can focus on the application specific code.

## Plugin types

### Mixin

Mixins add behaviours to the base application object itself: package name prefix is `application.mixin.`

### module

Modules wrap functionalities related to some specific domain into one property of the base object: package name prefix is `application.module.`

## Usage

## Set Dependency

    npm install application.skeleton

## Configuration

You can optionally pass a configuration that will be stored in the application object in a `config` property.

The structure of the config is up to you and your project, however there is one limitation: `config.modules` is reserved.
This config property is used to set configuration options for modules.

    var config = {
      "prop1": "someValue",
      "prop2": "whatever",
      "modules": {
        "application.module.socket": {
          "enableThis": true,
          "portRange": [25000, 25100]
        }
      }
    };

## Initialise

    var skeleton = require('application.skeleton');

    // load plugins
    skeleton(application, config);

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

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

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


text:
# README #

This is Eclipse project, you can import this directory as Eclipse project.

### Checkout source code ###

Execute following command.

`git clone https://github.com/alinous-core/codablecash.git`

### How to import into Eclipse workspace? ###

Click right mouse button on Package Explorer, and select "Import".

![Select Import](img/READMEIMG01.png "Select Import")

Select "Existing Projects Into Workspace" from "General" category. And push Next button.

![Import Dialog](img/READMEIMG02.png "Import Dialog")

Push "Browse..." button next to the "Select root directory" option, and select directory you cloned this project.

![Import Dialog](img/READMEIMG03.png "Import Dialog")

Push "Finish" button, then the directory is imported into Eclipse workspace as Java Project.

repository: alinous-core/codablecash

repo_name: alinous-core/codablecash


text:
# Release notes for Gluster 4.1.5

This is a bugfix release. The release notes for [4.1.0](4.1.0.md), [4.1.1](4.1.1.md), [4.1.2](4.1.2.md),
[4.1.3](4.1.3.md) and [4.1.4](4.1.4.md) contains a listing of all the new
features that were added and bugs fixed in the GlusterFS 4.1 stable release.

**NOTE:** Next minor release tentative date: Week of 19th November, 2018

## Major changes, features and limitations addressed in this release

**None**

## Major issues

**None**

## Bugs addressed

Bugs addressed since release-4.1.4 are listed below.

- [#1601356](https://bugzilla.redhat.com/1601356): Problem with SSL/TLS encryption on Gluster 4.0 & 4.1
- [#1625575](https://bugzilla.redhat.com/1625575): Prevent hangs while increasing replica-count/replace-brick for directory hierarchy
- [#1629548](https://bugzilla.redhat.com/1629548): Excessive logging in posix_set_parent_ctime()
- [#1630140](https://bugzilla.redhat.com/1630140): geo-rep: geo-rep config set fails to set rsync-options
- [#1630141](https://bugzilla.redhat.com/1630141): libgfchangelog: History API fails
- [#1630144](https://bugzilla.redhat.com/1630144): Geo-rep: Geo-rep regression times out occasionally
- [#1630145](https://bugzilla.redhat.com/1630145): Geo-rep: Few workers fails to start with out any failure

repository: gluster/glusterdocs

gha_language: HTML

repo_name: gluster/glusterdocs