text:
# Download and installation

ossutil supports the following operating systems: Windows, Linux, and macOS. You can download and install the ossutil version that best suits your requirements.

## Version and runtime environment

-   Current version: 1.7.1
-   Source code: [ossutil](https://github.com/aliyun/ossutil)
-   Runtime environment
    -   Windows/Linux/macOS
    -   Supported architectures: x86 \(32-bit and 64-bit\) and ARM \(32-bit and 64-bit\)

## Download URLs

-   [Linux x86 32bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutil32)
-   [Linux x86 64bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutil64)

    **Note:** When you copy the URLs to the wget command to download ossutil, delete the `? spm=xxxx` section from the URLs.

-   [Windows x86 32bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutil32.zip)
-   [Windows x86 64bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutil64.zip)
-   [macOS x86 32bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutilmac32)
-   [macOS x86 64bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutilmac64)
-   [ARM 32bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutilarm32)
-   [ARM 64bit](https://gosspublic.alicdn.com/ossutil/1.7.1/ossutilarm64)

## Installation

Download the package based on your operating system and run the corresponding binary file.

-   Install ossutil on Linux \(a 64-bit Linux system is used as an example\)
    1.  Download the ossutil installation package.

        ```
        wget http://gosspublic.alicdn.com/ossutil/1.7.1/ossutil64
        ```

    2.  Modify the execution permissions of the file.

        ```
        chmod 755 ossutil64
        ```

    3.  Generate a configuration file in interactive mode.

        1.  Run the following command:

            ```
            ./ossutil64 config
            ```

        2.  Configure the path of the configuration file as prompted.

            We recommend that you use the default path for the configuration file by pressing the Enter key.

            ```
            Please enter the config file name, the file name can include path (default C:\\Users\Administrator\.ossutilconfig, carriage return will use the default file.
            If you specified this option to other file, you should specify --config-file option to the file when you use other commands):
            ```

            **Note:** ossutil uses the default configuration file /home/user/.ossutilconfig if you do not specify a configuration file in the command. To force ossutil to use a custom configuration file, specify the file by adding the -c option in each command. For example, if you want to use the configuration file /home/config when you run the ls command, add the -c option in the following format:

            ```
            ./ossutil64 ls oss://examplebucket -c /home/config
            ```

        3.  Set the language of ossutil as prompted.

            ```
            Enter the language: CH or EN. The default language is CH. This parameter takes effect after the config command is run.
            ```

        4.  Configure the parameters including endpoint, AccessKey ID, AccessKey secret, and STS token.

            ```
            Please enter endpoint: Endpoint
            ```

            You can configure the following parameters for ossutil:

            -   endpoint: Enter the endpoint of the region in which your bucket resides. For more information about the endpoint of each region, see [Regions and endpoints](/intl.en-US/Developer Guide/Endpoint/Regions and endpoints.md).

                You can also add `http://` or `https://` to specify the protocol that ossutil uses to access OSS. The default protocol is HTTP. For example, if you want to access a bucket in the China \(Hangzhou\) region by using HTTPS, set the endpoint to `https://oss-cn-shenzhen.aliyuncs.com`.

            -   accessKeyID and accessKeySecret: Enter the AccessKey pair of your account.
                -   For more information about how to obtain the AccessKey pair of an Alibaba Cloud account or a RAM user, see [Create an AccessKey pair]().
                -   For more information about how to obtain the AccessKey pair of a temporary STS token, see [Access OSS with a temporary access credential provided by STS](/intl.en-US/Developer Guide/Data security/Access and control/Access OSS with a temporary access credential provided by STS.md).
            -   stsToken: This option is required only when you use a temporary STS token to access OSS buckets. Otherwise, you can leave this parameter empty. For more information about how to generate an STS token, see [Temporary access credential](/intl.en-US/Developer Guide/Objects/Upload files/Authorized third-party upload.md).
        **Note:** For more information about the configuration file of ossutil, see [config](/intl.en-US/Tools/ossutil/Common commands/config.md).

-   Install ossutil on Windows \(a 64-bit Windows system is used as an example\)
    1.  Click the download URL listed in the preceding section to download the installation package of ossutil.
    2.  Decompress the package. Double-click the ossutil.bat file.
    3.  Generate a configuration file. For more information about how to generate a configuration file, see [Generate a configuration file in interactive mode](#li_j6f_g28_vfx).

        You can run the following command to generate a configuration file:

        ```
        D:\ossutil>ossutil64.exe config
        ```

-   Install ossutil on macOS \(a 64-bit macOS system is used as an example\)
    1.  Download the ossutil installation package.

        ```
        curl -o ossutilmac64 http://gosspublic.alicdn.com/ossutil/1.7.1/ossutilmac64
        ```

    2.  Modify the execution permissions of the file.

        ```
        chmod 755 ossutilmac64
        ```

    3.  Generate a configuration file. For more information about how to generate a configuration file, see [Generate a configuration file in interactive mode](#li_j6f_g28_vfx).

        You can run the following command to generate a configuration file:

        ```
        ./ossutilmac64 config
        ```

repository: hglakfs/oss

filename: Download and installation.md

repo_name: hglakfs/oss


text:
# coherent

The text below is taken from http://www.nesssoftware.com/home/mwc/source.php

#Mark Williams Company Sources
OSI logo

This page contains links to Mark Williams Company (MWC) source code and documentation. This material was originally © Mark Williams Company. It is posted here as open source software by the current copyright holder Robert Swartz under a license complying with the Open Source Initiative. This site is not affiliated with or endorsed by the Open Source Initiative.

Mark Williams Company closed in 1995. In 2001, Bob Swartz asked me to archive the hard disks containing the Mark Williams source repository; the command and system sources here are from that repository. I have long intended to catalog and organize these sources, but in the meantime they are posted here as is. MWC's documentation guru Fred Butzen provided the MWC documentation sources.

Caveat utilitor, as Fred would say.
#License

Copyright © 1977-1995 by Robert Swartz.
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

This software is provided by the copyright holders and contributors "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the copyright holder or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage.

repository: proteanthread/coherent

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: proteanthread/coherent


text:
BFPaperTabBar
=============
I am no longer supporting this library.

[Please consider using BFPaperTabBarController instead, which I do support and works better than BFPaperTabBar!](https://github.com/bfeher/BFPaperTabBarController)

[![CocoaPods](https://img.shields.io/cocoapods/v/BFPaperTabBar.svg?style=flat)](https://github.com/bfeher/BFPaperTabBar)

> iOS UITabBar inspired by Google's Paper Material Design.

![Animated Screenshot](https://raw.githubusercontent.com/bfeher/BFPaperTabBar/master/BFPaperTabBarDemoGif.gif "Animated Screenshot")

*(The tiny dot on the bottom left is just the rounded corner of the iOS simulator showing. Also note that sometimes the iOS Simulator might show some strange color lines on the BFPaperTabBar. This does not show up on a real device.*

To Do
---------
[Convince you to use BFPaperTabBarController instead!!!](https://github.com/bfeher/BFPaperTabBarController)

Reordering tabs.

Adding/Removing tabs.

Stop crying while trying to implement the above.

About
---------
_BFPaperTabBar_ is a subclass of UITabBar that behaves much like the new paper tab bar from Google's Material Design Labs.
All animation are asynchronous and are performed on sublayers.
BFPaperTabBars work right away with pleasing default behaviors, however they can be easily customized! The tap-circle color, background fade color, tap-circle diameter, underline color, and underline thickness are all readily customizable via public properties.

By default, BFPaperTabBars use "Smart Color" which will match the tap-circle, background fade, and underline bar colors to the color of the `tabBar.tintColor`.
You can turn off Smart Color by setting the property, `.usesSmartColor` to `NO`. If you disable Smart Color, a gray color will be used by default for both the tap-circle and the background color fade.
You can set your own colors via: `.tapCircleColor` and `.backgroundFadeColor`. Note that setting these disables Smart Color.

## Properties
`BOOL usesSmartColor`

A flag to set YES to use Smart Color, or NO to use a custom color scheme. While Smart Color is the default (usesSmartColor = YES), customization is cool too.

`UIColor *tapCircleColor`

The UIColor to use for the circle which appears where you tap. NOTE: Setting this defeats the "Smart Color" ability of the tap circle. Alpha values less than 1 are recommended.

`UIColor *backgroundFadeColor`

The UIColor to fade clear backgrounds to. NOTE: Setting this defeats the "Smart Color" ability of the background fade. An alpha value of 1 is recommended, as the fade is a constant (clearBGFadeConstant) defined in the BFPaperTabBar.m. This bothers me too.

`CGFloat tapCircleDiameter`

The CGFloat value representing the Diameter of the tap-circle. By default it will be calculated to almost be big enough to cover up the whole background. Any value less than zero will result in default being used. Three pleasing sizes, `bfPaperTabBar_tapCircleDiameterSmall`, `bfPaperTabBar_tapCircleDiameterMedium`, and `bfPaperTabBar_tapCircleDiameterLarge` are also available for use.

`BOOL rippleFromTapLocation`

A flag to set to YES to have the tap-circle ripple from point of touch. If this is set to NO, the tap-circle will always ripple from the center of the tab. Default is YES.

`UIColor *underlineColor`

The UIColor to use for the underline below the currently selected tab. NOTE: Setting this defeats the "Smart Color" ability of this underline.

`CGFloat underlineThickness`

The CGFLoat to set the thickness (height) of the underline. NOTE: Any value greater than 1 will cover up the bottoms of low-hanging letters of a default TabBarItem's title.

`BOOL showUnderline`

A flag to set to YES to show an underline bar that tracks the currently selected tab.

`BOOL showTapCircleAndBackgroundFade`

A flag to set to YES to show the tap-circle and background fade. If NO, they will not appear.

Usage
---------
Add the _BFPaperTabBar_ header and implementation file to your project. (.h & .m)

### Using Storyboards
The easiest way to use a BFPaperTabBar is to set up a UITabBarController in your Storyboard and then set its UITabBar's class to BFPaperTabBar.
![Set Class](https://raw.githubusercontent.com/bfeher/BFPaperTabBar/master/set-class.png "Set Class")

### Programmatically Creating a BFPaperTabBar
```objective-c
BFPaperTabBar *tabBar = [[BFPaperTabBar alloc] init];
```

### Customized Example
*After setting your UITabBarController's UITabBar class to BFPaperTabBar: (Taken directly from example project.)*

```objective-c
((BFPaperTabBar *)self.tabBar).rippleFromTapLocation = NO;  // YES = spawn tap-circles from tap locaiton. NO = spawn tap-circles from the center of the tab.

((BFPaperTabBar *)self.tabBar).usesSmartColor = NO; // YES = colors are chosen from the tabBar.tintColor. NO = colors will be shades of gray.

((BFPaperTabBar *)self.tabBar).tapCircleColor = [[UIColor paperColorLightBlue] colorWithAlphaComponent:0.2];    // Set this to customize the tap-circle color.

((BFPaperTabBar *)self.tabBar).backgroundFadeColor = [UIColor paperColorGreen800];  // Set this to customize the background fade color.

((BFPaperTabBar *)self.tabBar).tapCircleDiameter = bfPaperTabBar_tapCircleDiameterLarge;    // Set this to customize the tap-circle diameter.

((BFPaperTabBar *)self.tabBar).underlineColor = [UIColor paperColorDeepPurpleA400]; // Set this to customize the color of the underline which highlights the currently selected tab.

((BFPaperTabBar *)self.tabBar).showUnderline = NO;  // YES = show the underline bar, NO = hide the underline bar.

((BFPaperTabBar *)self.tabBar).underlineThickness = 2.f;    // Set this to adjust the thickness (height) of the underline bar. Not that any value greater than 1 could cover up parts of the TabBarItem's title.

((BFPaperTabBar *)self.tabBar).showTapCircleAndBackgroundFade = NO; // YES = show the tap-circles and add a color fade the background. NO = do not show the tap-circles and background fade.
```

Cocoapods
-------

CocoaPods are the best way to manage library dependencies in Objective-C projects.
Learn more at http://cocoapods.org

Add this to your podfile to add BFPaperTabBar to your project.
```ruby
platform :ios, '7.0'
pod 'BFPaperTabBar', '~> 1.0.6'
```

License
--------
_BFPaperTabBar_ uses the MIT License:

> Please see included [LICENSE file](https://raw.githubusercontent.com/bfeher/BFPaperTabBar/master/LICENSE.md).

license: MIT

repository: bfeher/BFPaperTabBar

gha_language: Objective-C

repo_name: bfeher/BFPaperTabBar


text:
---
title: Q3 2021 Update
description: An update on our mission for Q3 2021.
date: 2021-10-26T00:00:00.000Z
authors: ['oliviertassinari']
card: true
tags: ['Company update']
---

This update covers our progress over the last three months.
It also covers what we aim to achieve in the months ahead.

## Overview

- [Product](#product)
  - [MUI Core](#mui-core)
  - [MUI X](#mui-x)
  - [Design kits](#design-kits)
- [Company](#company)
- [Our roadmap intent for Q4 2021](#our-roadmap-intent-for-q4-2021)

## Product

Here are the most significant improvements since early July 2021.

### MUI Core

- 🔥 In September we released a new major version: [v5.0.0](https://github.com/mui/material-ui/releases/tag/v5.0.0) (you might have noticed! 😄 ).
  We're excited about what it means for the future of the library, and we hope you are going to enjoy the simplified customization, the extra flexibility, new components, and more.
  It took us over a year to pull off, with an almost exclusive focus on v5 over v4.
  You can read more about it in the [release blog post](/blog/mui-core-v5/).
- ✨ We also introduced a brand new [product page](/core/) this quarter to better present what the Core is about.
- 🔎 We've reworked the search experience in the docs:

  - The component pages now rank before the API pages.
  - Instead of only displaying up to 5 results, you can scroll for more results.
  - An icon illustrates the nature of the match; either a page, a header, or a paragraph.
  - Your most recent searches are saved in local storage.

Before

After

- [Masonry](/components/masonry/). We introduced a new component for use when the `Grid` component leads to wasted space. It's frequently used in dashboards.

- We introduced a new [package of components without styles](https://www.npmjs.com/package/@mui/base), laying the foundations for supporting multiple design systems with headless components.
  While it was tough to balance the time between working on v5 stable and developing the unstyled components, we still managed to introduce the first few:

  - [Autocomplete](/components/autocomplete/#useautocomplete)

  ```jsx
  import { useAutocomplete } from '@mui/base/AutocompleteUnstyled';
  ```

  - [Button](/components/buttons/#unstyled)

  ```jsx
  import { useButton } from '@mui/base/ButtonUnstyled';
  ```

  - [Modal](/components/modal/#unstyled)

  ```jsx
  import ModalUnstyled from '@mui/base/ModalUnstyled';
  ```

  - [Slider](/components/slider/#unstyled)

  ```jsx
  import SliderUnstyled from '@mui/base/SliderUnstyled';
  ```

  - [Switch](/components/switches/#unstyled)

  ```jsx
  import { useSwitch } from '@mui/base/SwitchUnstyled';
  ```

  - [Portal](/components/portal/#unstyled)

  ```jsx
  import Portal from '@mui/base/Portal';
  ```

  - [TrapFocus](/components/trap-focus/#unstyled)

  ```jsx
  import TrapFocus from '@mui/base/Unstable_TrapFocus';
  ```

### MUI X

Last quarter we focused on the data grid components, working towards a stable release.
We also introduced a brand new [product page](/x/) this quarter to better present what MUI X is about.

#### Date Picker

The date picker sits at the border between the core component and advanced components.

- ❌ A few updates but no major ones worth sharing.
  With the release of v5 stable and our focus on the data grid, nobody in the team had the bandwidth to work on it.

#### Data Grid

- 🎉 We released the first stable version: [v4.0.0](https://github.com/mui/mui-x/releases/tag/v4.0.0)!
  We also released the first v5-beta, to support MUI Core v5,
  and will be working almost exclusively on the v5 release line going forward.
- 🔎 We also added a [quick-filter demo](/components/data-grid/filtering/#quick-filter) to illustrate how it can be implemented,
  and will add a [built-in](https://github.com/mui/mui-x/issues/202) solution later on.

- 🐛 We fixed several non-idiomatic React patterns, for instance we were not handling controllable props by the book, and as we do in MUI Core.
- 🚀 We introduced the [row editing](/components/data-grid/editing/#row-editing) feature.

- 🦺 We added a [`disableVirtualization`](/components/data-grid/virtualization/#disable-virtualization) prop to make it easier to test the data grid without a real browser environment, for example in jsdom with Jest.
- 🚛 We have added an `onViewportRowsChange` prop as a first step toward being able to lazy load a large dataset.
- Last but not least, we have resumed the work on [key missing features](https://github.com/mui/mui-x/issues?q=is%3Aopen+label%3A%22linked+in+docs%22+sort%3Areactions-%2B1-desc).
  Print export and tree data are in the pipeline.

### Design kits

We introduced a brand new [product page](/design-kits/) this quarter to better present the design kits.

#### Figma

The kit is now up-to-date with MUI Core v5,
and also includes the MUI X components. And, as always, we have been refining it in small areas for issues raised by our users in the support channel.

#### Adobe XD

No updates.

#### Sketch

No updates.

## Company

### Retreat

We held our first company retreat 🏝 in Lisbon, Portugal 🇵🇹 ,
for members of the team that were not prevented by COVID-19 related travel restrictions, and who felt safe enough to travel.
Less than half the company made it, but it was still fun!
We spent half the time doing a [Hackathon](https://twitter.com/olivtassinari/status/1441773885259583491) and the other half on activities (surfing, biking, winery tour, and sightseeing).

Sightseeing in Lisbon

### Growth between Q2 2021 and Q3 2021

- 📦 From 9.1M to 9.9M downloads per month on npm. We have 22.4% market share of the React ecosystem as a proportion of `react-dom` downloads.
- ⭐ From 69.1k to 72.1k stars. [Leave us yours 🌟](https://github.com/mui/material-ui)!
- 👨👩👧👦 From 2,223 to 2,316 contributors on GitHub. On average, one new contributor joins every day.
- 💰 Grew financial support by 2.99X [year over year](/blog/2020-q3-update/).

### New member

We welcomed one new member to the company this quarter 🏢:

- Benny was our first intern, and is now the first junior developer on the MUI Core team.

We are now 11 passionate builders empowering the next generation of UI creators.

### A new brand

Alongside the release of v5, we launched our [new brand](/blog/material-ui-is-now-mui/)!
We're excited about our new shorter name, **MUI**.
We were already using it in the class names (`.MuiButton-root`), which embodies our next step beyond Material Design.

This is something we have been considering for some time,
and we did a couple of early design studies with an outside agency,
but it was only after we secured [mui.com](https://mui.com/), the GitHub [`@mui`](https://www.npmjs.com/org/mui) org, and the npm [@mui](https://www.npmjs.com/org/mui) scope that we knew the new name would work.

## Our roadmap intent for Q4 2021

We'll do our best, no guarantee!

### MUI Core

- 🚀 We will double down on v5 before starting to solve new large problems, e.g. a revamp of the select.
  We have made bold changes in this version since v4, but until recently, only a small percentage of the community was using v5.
  In the last few weeks, we have seen a strong influx of feedback from the community.
  We need to make the most of this feedback to solve regressions, improve the documentation for the new APIs, adjust the tradeoffs we took in the light of more information, and more.
  [15%](https://npm-stat.com/charts.html?package=%40material-ui%2Fcore&package=%40mui%2Fmaterial&from=2020-10-25&to=2021-10-15) of the community has migrated, so far.
- 🦴 Migrate more components to `@mui/base`. [Michał](https://github.com/michaldudak) has recently added support for the [Button](https://mui.com/components/buttons/#unstyled).
  You can follow our progress in the [umbrella issue](https://github.com/mui/material-ui/issues/27170).
- 🎨 We are [exploring](https://github.com/mui/material-ui/discussions/29024) the introduction of CSS variables.
  Since v5, MUI is no longer actively supporting IE 11. Dropping this browser requirement unlocks new capabilities of the web platform.
- 🌈 Resume work on the second design system.
  Some users (and potential users) dislike Material Design. We'll try to make the second design system one that they love! You can check our [first RFC](https://github.com/mui/material-ui/discussions/29024).
- 🗓 Execute on all of the items in the [public roadmap](https://github.com/mui/material-ui/projects/25).
- ❓ Please upvote [GitHub issues](https://github.com/mui/material-ui/issues?q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc) if you want us to focus on a specific problem. The number of 👍 helps us to prioritize.

### MUI X

#### Data Grid

We have planned to:

- ✨ Release the print export feature.
- ✨ Release the tree data feature.
- ✨ Revamp the virtualization to yield better rendering performance and fix bugs.
  It unlocks new features like column pinning and lazy loading.
- 🗓 Execute on all of the items in the [public roadmap](https://github.com/mui/mui-x/projects/1).
- ❓ Please upvote [GitHub issues](https://github.com/mui/mui-x/issues?q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc) if you want us to focus on a specific problem. The number of 👍 helps us to prioritize.

#### Date Picker

No plans. We probably won't progress its development this quarter.

However, we are growing the team.
We plan to resume work on it in Q1 2022, starting with the equivalent of one full-time developer.

### Design kits

We will release a v5 for Sketch and Adobe XD, as we have already done for Figma.
While the visual difference between MUI Core v4 and v5 is not major, we still need to sync the design components.

### Company

We have the following objectives:

- 📊 Run a new edition of the Developer Survey. The last one was done [15 months ago](https://mui.com/blog/2020-developer-survey-results/). Now that v5 is released, it's time for the 2021 edition!
- 👪 Hire for two new roles: a Product Manager to focus on low-code and our first Developer Advocate.
- 💫 Create a great onboarding experience for the 6-7 new hires of Q4.

repository: oliviertassinari/material-ui

gha_language: JavaScript

gha_license_id: MIT

repo_name: oliviertassinari/material-ui


text:
# Background

When DSE client-to-server and server-to-server encryption (aka, in-transit SSL/TLS encryption) is enabled, the most important step is to create the keystore and truststore files for each DSE node. This step is conceptually clear, but practically it is complex and lenghthy. For example, DataStax documentation (https://docs.datastax.com/en/security/6.7/security/secSetUpSSLCert.html#secSetUpSSLCert) describes the procedure of how to create the keystore and truststore files based on self-signed root CA certificate. As we can see, the procedure involves quite a few steps and the procedure needs to be repeated for each DSE node.

# Script Description

## Objective

The purpose of this script is to automate the procedure as described in the above DataStax documentation for the creation of the keystore and truststore files as needed for every node in a DSE cluster.

## Usage Description

The general script usage is as below:
```
Usage: genSelfSignSSL.sh [-h | <hostname_or_ip_list_file> <JKS|PKCS12>]
```

There are 2 mandatory parameters for this script:
1. The first is a text file name and the content of the file is a simple list of the hostname or IP address for all DSE nodes we want to create the keystore and truststore for in-transit SSL/TLS encryption. An example is as below (for a 3-node DSE cluster):
```
<IP_ADDRESS>
<IP_ADDRESS>
<IP_ADDRESS>
```
2. The second parameter specifies the certificate format to be used. The only options are JKS and PKCS12 which are both file-based certificate format types.

## Output

For the above 3-node DSE cluster, the DSE node list file is simply called **nodelist**. The command to generate PKCS12 based keystore and trustore files is as below. Please note that the execution of the command is generating a lot of command line messages describing each step involved.
```
$./genSelfSignedSSL.sh nodelist PKCS12
```

With the execution of this command, a folder called **SelfSignedSSL** is created under the current folder where the command is executed. Under this folder, there are subfolders that match the specified certificate format type ("pkcs12" in this example). Below this folder, the folder structure is as this:
* **.../cqlsh/**: the generated CQLSH client certificate (.csr) and private key (.key) for each DSE node

* **...keystore/**: the keystore file of the specified certificate format type (e.g. pkcs12) for each DSE node
  * **.../keystore/csr/**: the CSR (.csr) and signed certificate (.crt.signed) for each DSE node.

* **rootca**: the self-signed root ca certificate (.crt) and private key (.key)

* **truststore**: the one (and only one) trsustore file of the specified certificate format type (e.g. pkcs12) that is shared by all DSE nodes.

```
$ tree SelfSignedSSL/
SelfSignedSSL/
└── pkcs12
    ├── cqlsh
    │   ├── cqlsh_192-168-0-1.crt.signed
    │   ├── cqlsh_192-168-0-1.csr
    │   ├── cqlsh_192-168-0-1.key
    │   ├── cqlsh_192-168-0-2.crt.signed
    │   ├── cqlsh_192-168-0-2.csr
    │   ├── cqlsh_192-168-0-2.key
    │   ├── cqlsh_192-168-0-3.crt.signed
    │   ├── cqlsh_192-168-0-3.csr
    │   └── cqlsh_192-168-0-3.key
    ├── keystore
    │   ├── csr
    │   │   ├── dseKeystore-192-168-0-1.crt.signed
    │   │   ├── dseKeystore-192-168-0-2.crt.signed
    │   │   ├── dseKeystore-192-168-0-3.crt.signed
    │   │   ├── dseKeystore_192-168-0-1.csr
    │   │   ├── dseKeystore_192-168-0-2.csr
    │   │   └── dseKeystore_192-168-0-3.csr
    │   ├── dseKeystore_192-168-0-1.pkcs12
    │   ├── dseKeystore_192-168-0-2.pkcs12
    │   └── dseKeystore_192-168-0-3.pkcs12
    ├── rootca
    │   ├── rootca.crt
    │   └── rootca.key
    └── truststore
        └── dseTruststore.pkcs12
```

Please **NOTE** that you can execute this script on any computer. Once the files are generated, you can copy the files to all the nodes in cluster:
* Copy the common truststore file to each DSE node
* Copy each keystore file to the corresponding DSE node
* Copy each pair of CQLSH certificate and key files to the corresponding DSE node.

Please also **NOTE** that the generated keystore and truststore passwords are "MyKeyStorePass" and "MyTrustStorePass" respectively. These are hard-coded in the script. Please change them accordingly for your own use case.

## About the Certificate Format JKS and PKCS12

* For DSE version before 6.7.7, JKS is the ONLY format that works for DSE in-transit SSL/TLS encryption.
* For DSE verion 6.7.7 and above, both formats are working but PKCS12 is recommended.

repository: yabinmeng/dseutilities

repo_name: yabinmeng/dseutilities


text:
# LoopLAB-Theme-Design

<feat>: **LoopLAB Theme Design**

This theme is designed by Bipronath Saha using BOOSTRAP version 4.6 .

_[BOOTSTRAP V4.6docx] {https://getbootstrap.com/docs/4.6/getting-started/introduction/}_

branch_name: refs/heads/main


text:
# react_fabricjs_drawboard
Simplistic react component with draw tools based on FabricJS. Demo: https://react-drawboard.charlesdlandau.now.sh/

I wrote this to demonstrate how to create FabricJS drawing tools in a GUI using ReactJS. It was written pre-hooks and I have no plans to transition the project to hooks.

### `Board.js`
Just handles the FabricJS canvas object.

### `DrawBoard.js`
Displays the canvas, the buttons, and applies the `utils`

### `utils`

1. doStack.js
Handles the undo and redo features
2. eventHandlers
Handles the mouse events (Up Down, moving) with fabricJS methods -- the actual drawing features are implemented here.


text:
# Instructor Resources for this Course

More Resources COMING SOON

## Summary of this Repository

`bot-education` is a place for training resources around Microsoft Bot Framework and Cognitive Services bot-related topics.  This includes samples, labs, guides and documentation.

For additional resources see the [Additional Resources](ADDITIONAL_RESOURCES.md) section.  This has links to helpful articles, videos, instructions and more.

##  What can be found in `bot-education`

**Samples**
* Sample bots in Visual Studio solution formats (C#)
* Sample bots for Node.js SDK
* Sample Cognitive Services API code snippets (as Jupyter notebooks mainly) found [here](/Student-Resources/CognitiveServices/Notebooks)
* Sample Azure Machine Learning solutions (e.g. anomaly detection) found [here](/Student-Resources/AzureMachineLearning/Notebooks)

**Labs**
* [Getting Started in the .NET SDK](/Student-Resources/Labs/Lab_Getting_Started.md)
* More labs [here](/Student-Resources/Labs/)

**Student Handouts**
* Under [Handouts](/Student-Resources/Handouts) (updated often usually for each event)

repository: michhar/bot-education

repo_name: michhar/bot-education


text:
# Delani Studios

This is a  delani studio I built to aid better my grasp of various concepts in Bootstrap and JQuery.

#### Done by:Mugisha Beline

## Getting Started
You can access this project [here](https://mugisha-beline.github.io/delani-studio/)
## Deployment

Click [here](https://mugisha-beline.github.io/delani-studio/) to go to the live site.<br>

## Built With
* HTML- The markdown language used to add content.
* CSS - Used to style the HTML.
* Bootstrap - Used to style the content in a standardized manner.
* JQUERY - Used to make the web page dynamic and manipulating the DOM.

## Author's Contact
If you need any clarifications or have feedback on this project , contact the author at [belinemugisha21@gmail]

## License
This software is Licensed under MIT license Copyright (2021) get it [here](https://opensource.org/)

repository: Mugisha-Beline/delani-studio

repo_name: Mugisha-Beline/delani-studio


text:
# Client Example

The Client is useful when working with multiple hostnames.

See the simplest `sendGetRequest()` for GET and more advanced `sendPostRequest()` for a POST request.

The `sendPostRequest()` also shows:
* Per-request timeout with `DoTimeout()`
* Send a body as bytes slice with `SetBodyRaw()`. This is useful if you generated a request body. Otherwise, prefer `SetBody()` which copies it.
* Parse JSON from response
* Gracefully show error messages i.e. timeouts as warnings and other errors as a failures with detailed error messages.

## How to build and run
Start a web server on localhost:8080 then execute:

    make
    ./client

## Client vs HostClient
Internally the Client creates a dedicated HostClient for each domain/IP address and cleans unused after period of time.
So if you have a single heavily loaded API endpoint it's better to use HostClient. See an example in the [examples/host_client](../host_client/)

repository: valyala/fasthttp

gha_language: Go

repo_name: valyala/fasthttp


text:
---
title: 'Conceptual model'
published: true
tags: Network
---

A conceptual model is a representation of a system. It consists of concepts used
to help people know, understand, or simulate a subject the model represents. It
is also a set of concepts. In contrast, physical models are physical objects;
for example, a toy model which may be assembled, and may be made to work like
the object it represents.

Conceptual model may refer to models which are formed after a conceptualization
or generalization process.[1][2] Conceptual models are often abstractions of
things in the real world, whether physical or social. Semantic studies are
relevant to various stages of concept formation. Semantics is basically about
concepts, the meaning that thinking beings give to various elements of their
experience.

## Reference

- [https://en.wikipedia.org/wiki/Conceptual_model](https://en.wikipedia.org/wiki/Conceptual_model)

gha_language: HTML


text:
Returns the last UID assigned to a client. As this counts upwards, it's the best way to loop through all clients:

```cpp

for(int i = 0; i < TCP.getLastID(); i++) // getLastID is UID of all clients
{

		if( TCP.isClientConnected(i) ) { // check and see if it's still around
		  // maybe the client is sending something
		  string str = TCP.receive(i);
		  TCP.send(i, "You sent: "+str);
		}
}
```

gha_language: Ruby


text:
# tyne

[![travis-ci](https://api.travis-ci.org/tyne/tyne.png)](http://travis-ci.org/#!/tyne/tyne) [![Dependency Status](https://gemnasium.com/tyne/tyne.png)](https://gemnasium.com/tyne/tyne) [![Code Climate](https://codeclimate.com/github/tyne/tyne.png)](https://codeclimate.com/github/tyne/tyne)

## Description

Tyne is a webbased issue tracking application with the following features:
* Github authentication
* Project management
* Issue tracking (includes sorting, filtering, basic workflow, etc.)
* Basic role management
* Agile sprint planning

Do you want to check the current status of the project? We have deployed a demo to http://www.tyne-tickets.org

## Installation

### Gem dependencies

Run the following command to install all the dependencies:
```
bundle install
```

### Database configuration

Enter your database details: ```config/database.yml```

Run the following command: ```bundle exec rake db:setup```

### OmniAuth configuration

In order to use OmniAuth via Github you need to set up some environment keys. Add the following to your ```.bash_profile``` or ```.bashrc```.

```bash
export GITHUB_KEY=your_key
export GITHUB_SECRET=your_secret
```

You will need to register a new developer application in order to get those details. Simply go to https://github.com/settings/applications and register a new application with the following details:

```
Name: Tyne (localhost)
URL: http://localhost:3000
Callback URL: http://localhost:3000/auth/github/callback
```

### Start the server

Start your rails server via ```rails s```

## Testing

You can run the following command to run the whole test script: ```script/ci```

## Contact us

Please don't hesitate to ask any questions at our google groups.

For general questions please use the following discussion list: [tyne-talk@googlegroups.com](http://groups.google.com/group/tyne-talk)

If you have questions to the internals of tyne or just want to propose some changes, please use the following discussion list: [tyne-core@googlegroups.com](http://groups.google.com/group/tyne-core)

## Contribute

Please read our [contribution-guidelines](https://github.com/tyne/tyne/blob/master/CONTRIBUTING.md).

Note Also that this repository contains submodules so cloning is best done like so:

```bash
git clone --recursive git@github.com:tyne/tyne.git
```

Or if you have already cloned it, run this in your repo root:

```bash
git submodule init
git submodule update
```

## Maintainers

* Tobias Haar (http://github.com/Tobscher)
* Michael Lessnau (http://github.com/mlessnau)

## License

MIT License. Copyright 2012 - 2013 Tobias Haar.

repository: loz/tyne

repo_name: loz/tyne


text:
# PostCSS Variables Rewrite [![Build Status][ci-img]][ci]

[PostCSS] plugin for rewriting the variables path in @import.
Its main purpose is to provide theme support in the webpack build process.

[PostCSS]: https://github.com/postcss/postcss
[ci-img]:  https://travis-ci.org/radojesrb/postcss-variables-rewrite.svg
[ci]:      https://travis-ci.org/radojesrb/postcss-variables-rewrite

### Why to use it
Imagine that you develop UI reusable component pattern library. You have centralized handling of the color palette but you need to have local mapping of that palette to the component styles. So that you have the possibility to do the following:

**Button/css/Button.scss**
```css
@import './variables';

.button--color-primary {
  background-color: $primary;
}
```

**Button/css/variables.scss**
```css
@import '~styles/colors/colors';

$primary: $green;
```

**Button/css/variables.blue.scss**
```css
@import '~styles/colors/colors';

$primary: $blue;
```

This plugin will provide an easy way to rewrite the ```@import``` statement so that during the build process we can build separate bundles for each theme.
Scoping styles to component level is very important and handling theme in not direct way is even more important.

## Usage

```js
postcss([ require('postcss-variables-rewrite')({
  originalValue: './variables',
  targetValue: './variables.blue'
})])
```

**webpack**
```js
{
  loader: 'postcss-loader',
  options: {
    ident: 'postcss',
    plugins () {
      return [
        require('postcss-variables-rewrite')({
          originalValue: './variables',
          targetValue: './variables.blue'
        })
      ]
    }
  }
}
```

Where **targetValue** can be defined based on the env variable in our case:
```yarn build --env.theme=blue```

See [PostCSS] docs for examples for your environment.

repository: radojesrb/postcss-variables-rewrite

repo_name: radojesrb/postcss-variables-rewrite


text:
# PivotPi
PivotPi is a Servo Controller for the Raspberry Pi!

## Installation
If you are running Raspbian for Robots image from Dexter Industries, they you should just run the DI update on the Desktop.

If you are running your own custom image. You will have to run the install script first.

Make the install script executable:

`sudo chmod +x install.sh`

Run the install.sh script to install the PivotPi libraries:

`sudo bash install.sh`

## Getting Help
Need help? We [have a forum here where you can ask questions or make suggestions](http://forum.dexterindustries.com/c/pivotpi-servo-controller-for-raspberry-pi.

See more at the [PivotPi Site](https://www.dexterindustries.com/pivotpi/)

## License

The MIT License (MIT)

PivotPi is a Servo Controller for the Raspberry Pi!
Copyright (C) 2016  Dexter Industries

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: RobertLucian/PivotPi

repo_name: RobertLucian/PivotPi


text:
---
layout: default
---

## Week 4 - Overview

Students should be comfortable with the following at the end of this week:

* Rails
* HTML Verbs
* Routing
* Controllers
* Params
* JBuilder

## Important Links

* [Challenge Submission Form](http://goo.gl/forms/OzzXZL6iEF)
* [Homework Submission Form](http://goo.gl/forms/o9so3mi9Sd)

## Tuesday - Rails and the Web

**Challenge:** [Composition](https://github.com/masonfmatthews/rails_assignments/blob/master/challenges/composition_challenge.rb)

**Problem of the Day:** [Folder Structure](https://github.com/masonfmatthews/rails_assignments/blob/master/exercises/folder_structure)

* Human Learning:
  * Scarring with age/experience
  * Good scarring example: Saving hardest things for last sucks
  * Bad scarring example: Given one bad experience, some people assume that Millenials are all lazy.
  * Bad scarring example: Taking risks on products costs too much money.
  * Diagram: Topological map of scarring
* The Web
  * IP addresses
  * Ports
  * Request/Response
  * Servers
* Rails Introduction
  * `rails new`
  * `bin/rails server`
  * Rails folder structure
  * MVC
  * `bin/rails generate model`
  * `bin/rake db:migrate`
  * `bin/rails generate migration`
  * `bin/rails console`
  * `bin/rails generate controller`
* Unit Testing in Rails

#### Lecture Notes/Links

* [Class Video](http://youtu.be/CYYcNxMNV1w)
* [Example Odd Array Solution](w4-1/odd_array.rb)
* [Example DayForecast Class](w4-1/ten_day_forecast.rb)
* [Our First Rails Project!!](https://github.com/tiyd-rails-2015-05/langhorn_slim_and_the_law)
* [Rails Guides](http://guides.rubyonrails.org/index.html)

#### Evening Reading

* [Why Learning Code is Hard](http://www.vikingcodeschool.com/posts/why-learning-to-code-is-so-damn-hard)

#### Assignment

Get a start on [Create a Voting API](https://github.com/tiyd-rails-2015-05/voting_api):

* Review the requirements and create an ERD
* Create a new Rails app
* Create migrations and models as needed
* Add associations and validations
* Create at least two unit tests for each model
* Make sure that you can run `rake` successfully to run the tests
* Make sure that you can run `rails server` and see the default page in your browser
* Create the `candidates` controller with an `index` action
* Make sure that you can access it in your browser
* Delete `README.rdoc` and make your own (filled in) `README.md`
* Push to GitHub
* Create an estimate for the number of hours you expect to need to complete this assignment tomorrow night

If you anticipate getting to hard or nightmare modes, read those modes before beginning work tonight and take those requirements into account in your models and migrations.

## Wednesday - Controllers and the Router

**Challenge:** [Enumerable](https://github.com/masonfmatthews/rails_assignments/blob/master/challenges/enumerable_challenge.rb)

**Optional Challenge:**
[Primes](https://github.com/masonfmatthews/rails_assignments/blob/master/challenges/primes_challenge.rb)

**Problem of the Day:** [Model to JSON](https://github.com/masonfmatthews/rails_assignments/blob/master/exercises/model_to_json)

* Human Learning: How to Google
  * [XKCD on Old Forums](https://xkcd.com/979/)
  * Two types of resources: tutorials and answers.
    * Stackoverflow is great for answers.
    * Blogs (and Rails Guides) are great for tutorials.
  * Be as specific as you can about which technologies you're using.  `ActiveRecord::Base` is a better start to your search than `Rails`
  * You can try questions (e.g. `How do I use ActiveRecord?`)
  * Use Google to dig deeper into someone else's docs (e.g. `weather underground api sunrise`)
  * Search for a module's "API"
* What is an API?
  * The term is way more broad than we think it is.
  * Each class in your application technically has an API.  It's the set of methods you can call on it and its instances.
* Random Topics:
  * `rake db:rollback`
  * `rake db:drop`
* HTML Verbs
  * GET (google.com)
  * POST (coursyl.com)
  * PATCH
  * DELETE
  * Postman
* The Router
  * `config/routes.rb`
* Controllers
* Fat Models, Skinny Controllers
* Controller Testing

#### Lecture Notes/Links

* [Class Video](http://youtu.be/4Zet5JP9nkc)
* [Updated Example App](https://github.com/tiyd-rails-2015-05/langhorn_slim_and_the_law)
* [Postman](https://chrome.google.com/webstore/detail/postman-rest-client/fdmmgilgnpjigdojojpjoooidkmcomcm?hl=en)

#### Evening Reading

* [Building API Basics](http://www.theodinproject.com/ruby-on-rails/apis-and-building-your-own)
* [Railscast on securing APIs](http://railscasts.com/episodes/352-securing-an-api)

#### Assignment

[Create a Voting API](https://github.com/tiyd-rails-2015-05/voting_api).  After you're done, reflect on your estimate from last night:

  * In theory, your estimate should be better now that you've gotten part of the way through the project.
  * Document your number of hours worked at the end.

## Thursday - Serializers, More Database

**Challenge:** [Include](https://github.com/masonfmatthews/rails_assignments/blob/master/challenges/include_challenge.rb)

**Problem of the Day:** [Assorted JSON](https://github.com/masonfmatthews/rails_assignments/blob/master/exercises/assorted_json/)

* Random Topics
  * Explore Rails' Gemfile
  * Dev and Test databases are separate
  * Memoization (`||=`)
  * `as_json`
* Fixtures
* Seeds
* Views and Controller Instance Variables
* Callbacks
  * `before_create`, etc.
* JBuilder
  * `json.name @candidate.name`
  * `json.extract! @candidate, :id, :name, :party`
  * `json.array! @candidates, :id, :name, :party`

#### Lecture Notes/Links

* [Class Video](https://youtu.be/F3tBHnAXb-U)
* [Nate's App Modified During Class](https://github.com/tiyd-rails-2015-05/voting_api_example)
* [Rails Guide on Callbacks](http://guides.rubyonrails.org/v2.3.11/activerecord_validations_callbacks.html#callbacks-overview)
* [JBuilder](https://github.com/rails/jbuilder)
* [JBuilder Railscast](http://railscasts.com/episodes/320-jbuilder)

#### Evening Reading

* [Ruby Rogues: Pair Programming](http://devchat.tv/ruby-rogues/026-rr-pair-programming)

#### Assignment - IN PAIRS

Get a start on [Build Your Own API](https://github.com/tiyd-rails-2015-05/novel_api)

* Plan your API.
* Investigate your options for existing API data sources.  Register accounts as necessary.
* Create a GitHub organization and a new repository
* Write code in non-ActiveRecord models which successfully pulls from each of your target data sources.  You don't have to do anything with the data they give you back yet.
* Create skeleton controllers with the actions you intend to use (you don't need code in those actions yet).
* Write one test which mocks an API call so that you don't have to hit the real third-party APIs during testing.

## Friday Mini-lecture

* Router
  * `rake routes`
  * Level 1 - we know this.
  * Level 2 - Naming addresses in a more custom way
  * Level 3 - Putting `id`s (or other `params`) in paths
* Different kinds of API auth
  * Gems for accessing APIs
  * Token Auth in params
  * Token Auth in headers
  * Basic Auth (not so good)
  * OAuth - later
* Non-ActiveRecord Models (don't `generate`!)
* Testing Validations - not as important as I let on.

#### Lecture Notes/Links

* [Class Video](https://youtu.be/1LXn5fYWsXU)
* [Example Routes from Class](w4-4/routes.rb)
* [Example Test Mocking from Class](w4-4/game_review_test.rb)

#### Evening Reading

* [Pro Git Ch. 3.3](http://git-scm.com/book/en/v2/Git-Branching-Branch-Management)
* [Pro Git Ch. 3.4](http://git-scm.com/book/en/v2/Git-Branching-Branching-Workflows)

## Weekend Assignment - IN PAIRS

[Build Your Own API](https://github.com/tiyd-rails-2015-05/novel_api)


text:
---
date: 2021-05-10
title: Data flow analysis
technologies: [java]
topics: [latest]
author: tg
subtitle: Data flow analysis is always being improved to show us potential errors in our logic.
thumbnail: ./thumbnail.png
cardThumbnail: ./card.png
shortVideo:
  poster: ./tip.png
  url: https://youtu.be/toySbTAKD7c
seealso:
  - title: IntelliJ IDEA Help - Analyze data flow
    href: https://www.jetbrains.com/help/idea/analyzing-data-flow.html
leadin: |
  IntelliJ IDEA's data flow analysis can locate places where we could have errors in our code. For example, if we use a negative number for initialising an array, or checking for negative values where the value couldn't be negative.

---


text:
---
layout: post
title: code and block test
---

## 1. Fenced code blocks inside ordered and unordered lists

```
sudo apt-get
```

## 2. xxxx

```
sudo reboot
```

1. This is a numbered list.
2.  We can put fenced code blocks inside nested bullets, too.
   1. Like this:

        ```c
        printf("Hello, World!");
        ```

   2. The key is to indent your fenced block by **(4 * bullet_indent_level)** spaces.

        ```javascript
         var x = 1 + 2;
         console.log(x);
        ```

   3. Also need to put a separating newline above and below the fenced block.

---

## Failed attempts:

1. This is a bullet.
2. This is the end of the first bullet list, with a fenced code block following:

```
Code
More Code
```

3. This is the start of a new bullet list.  Maybe we can do it with indenting?
     Did that work?  Now I will try more indenting, to match the bullet margin, plus 4:

       Code
       More Code

7.  Well that was disappointing.  No such luck.

---

* Oh look, it's some [Apache config](http://pygments.org/docs/lexers/#lexers-for-non-source-code-file-types):

    ```apache
    <Directory /foo/bar>
      Order allow,deny
      Deny from all
    </Directory>
    ```

* Wasn't that fun?


text:
---
layout: post
title: IARI Lower Division Clerk vacancy last date 4th March-2016
date: 2016-02-08 06:06
comments: true
tags:  Agriculture Clerk Institute Online
archive: false
---
Online applications   are  invited  for  filling  up  the  following  posts of Lower Division Clerk (LDC) under  Direct  Recruitment  Quota  at  ICAR-IARI,  New  Delhi  and  its  Regional  Stations  /  Research  Centres  under  the administrative control of Indian Council of Agricultural Research (ICAR) :

- Lower Division Clerk (LDC)   : 21 posts, Pay Scale : PB-I Rs. 5200 – 20200 plus Rs. 1900 Grade Pay, Age : 18-27 years as on 01/01/2016.

Application Fee :  Rs.250/- (SC/ST/Women/PwD/Ex--servicemen are exempted from fee) to be  paid  by Demand Draft  /Pay  Order  favouring   Director,   Indian Agricultural Research Institute,  New  Delhi  payable at  IARI,  New  Delhi.

**How to Apply** : Apply Online IARI website from 05/02/2016 to 04/03/2016 only. Print out and demand draft should be send by Speed Post / Registered Post to The Senior Admn. Officer (Recruitment Cell),  Room No.13, Director’s Office, ICAR -  Indian Agricultural Research Institute,  Pusa Campus, New Delhi –  110012 (India).

Please visit <http://iari.res.in/rec_cell/recruitmentcell/home.php> for details and online submission of application.

repository: anchalrani/getopportunity

repo_name: anchalrani/getopportunity


text:
# simulations

[![Build Status](https://travis-ci.org/gsmcwhirter/simulations.png?branch=develop)](https://travis-ci.org/gsmcwhirter/simulations)

This package serves as the base framework for simulating
evolutionary game theoretic models and creating reports
from the results.

## Tests

Tests are written for nose. To run the tests, install in a virtualenv
and then run

    python setup.py test

## License

MIT (see LICENSE file)

repository: gsmcwhirter/simulations

branch_name: HEAD

repo_name: gsmcwhirter/simulations


text:
# Welcome to `egypt-citis` package!
[![Build Status](https://travis-ci.org/AhmadIbrahiim/egypt-cities.svg?branch=master)](https://travis-ci.org/AhmadIbrahiim/egypt-cities)

`egypt-citis` is an easy to use Node.js library to allow you to lookup a city and all nested areas!

At the moment, this package only supports cairo cities only. There are plans to extend this in the
next version.

### Install

```
npm install egypt-cities --save
```

### Usage

```
var cities = require('egypt-cities');
```
#### Get all cities

```
cities.localCities('NJ')
```

### Sample Response

A sample response or object that this module returns looks like this.

```
[	{
		"city_name" : "القاهره"
	},
	{
		"city_name" : "الجيزة"
	},
	{
		"city_name" : "السادس من أكتوبر"
	}
    ...
    ]
```
## License

MIT.

repository: AhmadIbrahiim/egypt-cities

repo_name: AhmadIbrahiim/egypt-cities


text:
# Earthquake Relief Tracer

Earthquake Relief Tracer is a prototype for a decentralized web application built on the Ethereum blockchain that empowers users to make traceable charity donations for earthquake relief. The user can make a donation in ETH to a selected charity at any time using their MetaMask wallet. As soon as an earthquake of at least 8.0 magnitude is reported, the user's donation will be automatically disbursed to the charity's MetaMask wallet. Only then can the designated charity's wallet withdraw the funds. The transaction history of the donation's deposit and withdrawal is recorded on the Ethereum blockchain for future reference by all stakeholders.

# Technologies used:

- Javascript
- React
- Solidity
- Web3
- Truffle
- Ganache
- MetaMask
- Remix IDE

On the back end, the app's escrow functionality is built with a smart contract written in Solidity. When external data provided to the smart contract fulfills a pre-defined condition, the smart contract will automatically execute by disbursing ETH collected from one wallet to another specified wallet. Remix was the IDE used to develop and test the smart contract.

On the front end, React was used to create a single page application and dynamically render payment status updates in a performant way. Web3 was used to programmatically access the smart contract and Ethereum blockchain from within React components.

Truffle was used to help build and deploy the smart contract to a test blockchain provided by Ganache. MetaMask was connected to these developer tools to test payments from one wallet to another.

This app was bootstrapped with a Truffle Box that utilizes Create React App.

# Steps to run locally:

1. Fork and clone this repo
2. npm i
3. truffle develop
4. compile
5. migrate
6. In another terminal, to start the app, cd client npm run start
7. Open a local personal instance of an Ethereum blockchain via Ganache and configure the port number to match the localhost for MetaMask (7545) per the port set in the truffle-config and getWeb3.js
8. Log into a test MetaMask account for the transaction sender (donor). Add test ETH to the sender's wallet (e.g. https://faucet.metamask.io/). Follow the prompts in the 'Donate' view to send ETH to be held in escrow.
9. Navigate to the 'Update seismic data' view. Log into the test MetaMask account for the geological data provider. Follow the prompts to submit an integer for the seismic level (must enter at least 8.0 or up to enable ETH held in escrow smart contract to be withdrawn by the recipient wallet). Confirm transaction in MetaMask.
10. Navigate to the 'Receive donation' view. Log into a test MetaMask account for the recipient (charity). Follow the prompts to withdraw ETH held in the escrow contract. Confirm transaction in MetaMask.

Note: Until navigation is fixed, the browser must be refreshed to render the forms in each view for donating, updating the seismic data, and withdrawing the funds.

# Planned bug fixes and updates:

- Fix React routes so page refresh isn't required to render each view.
- Build out true oracle functionality to feed real-world seismic data figures into the smart contract to replace the existing manual input option for entering seismic data.
- Use Drizzle components to improve UX/UI, keep code more DRY by re-using modular components, and reduce manual configuration.
- Refactor React class components to use functional components and hooks where possible
- Create develop branch so pull requests can be made to develop first before those commits are merged to master.

repository: MalloryLeeWong/stackathon

repo_name: MalloryLeeWong/stackathon


text:
# i18n-plus

[![GitHub issues](https://img.shields.io/github/issues/artus9033/i18n-plus?style=flat-square)](https://github.com/artus9033/i18n-plus/issues)
[![GitHub forks](https://img.shields.io/github/forks/artus9033/i18n-plus?style=flat-square)](https://github.com/artus9033/i18n-plus/network)
[![GitHub stars](https://img.shields.io/github/stars/artus9033/i18n-plus?style=flat-square)](https://github.com/artus9033/i18n-plus/stargazers)
[![GitHub license](https://img.shields.io/github/license/artus9033/i18n-plus?style=flat-square)](https://github.com/artus9033/i18n-plus/blob/master/LICENSE)

A node.js package providing i18n with variable interpolation & conjugation of words with respect to quantifiers, supporting all languages' conjugation rules.

## Features

-   Translating strings using user-defined dictionaries (key-value system)
-   Interpolation of strings with variables
-   User-defined conjugation (e.g. for pluralization, grammatical case conjugation, etc.) with respect to the quantity, passed in as a variable
-   Strongly typed with TypeScript
-   Transpilation of YAML-defined translation key dictionaries into statically-typed, importable TypeScript code
-   Supports splitting key dictionaries into multiple files with `!include()` directives

---

## Documentation

You can read the full documentation with examples [there](https://artus9033.github.io/i18n-plus/).

---

## Usage

### Basic usage in a brief

The key function provided is `trans(key, interpolationParams = {})`

There are two specifiers available for use:

1. Interpolation syntax `:variableName` - simply replaces all such fields with the corresponding values supplied as Object properties in the second argument of `trans` call
2. Conjugation syntax `:[quantityVarName, { zero: 'values', one: 'value', other: 'values' } ]` -

```javascript
import { Locales, LocaleHelper, Translation } from "i18n-plus";

// these will be the keys used in the dictionary to identify texts
const localeKeys = {
	home: { welcome: "home.welcome" },
};

// this is the actual translation for a single language
const translationEN: Translation<typeof LocaleKeys> = {
	home: {
		welcome:
			"Welcome, :user! You have :[messages, { zero: 'messages', one: 'message', other: 'messages' }]",
	},
};

let localeHelper = new LocaleHelper(localeKeys, {
	[Locales.en]: translationEN,
});

// here, you can do whatever you want with the translated & interpolated text, e.g. send it with an HTTP response, render it as a React or HTML component, log it to the console, etc.

let welcomeMessage = localeHelper.trans(localeKeys.home.welcome, {
	user: "Elon Musk",
	messages: 5,
});
```

### Advanced usage - defining

What makes this library special is the integrated CLI that enables developers to define their translation keys in a ligthweight, clean manner, by placing them in YAML with support for additional directives.

Considering the above example:

```javascript
const localeKeys = {
	home: { welcome: "home.welcome" },
};
```

can be re-written as:

```yaml
home:
    - welcome
```

which is transpiled by the CLI to just the TS code above which can be imported right into the actual project code. To do so, the project supports two scenarios:

-   single-time compilation, e.g. in a buildscript: `i18n-plus compileKeys keys/entrypoint.yaml i18n/LocaleKeys.ts`, which would compile `keys/entrypoint.yaml` into TS and output the bundle to `i18n/LocaleKeys.ts`
-   development compilation with watching, e.g. in a development script, which does the same as the above scenario, but also watches for changes in all files referenced by the entrypoint and the entrypoint itself, recompiling & rebuilding file dependency tree on file changes. The command is the same, all that is needed is just appending the `--dev` (or short `-d`) switch: `i18n-plus compileKeys keys/entrypoint.yaml i18n/LocaleKeys.ts --dev`

You can easily access the documentation of the tool by running `i18n-plus -?`, `i18n-plus -h`, or just failing to provide a valid command syntax, which will trigger help automatically and describe the problem on the bottom, e.g. running `i18n-plus compileKeys keys/entrypoint.yaml` (please note the missing output path) will print the following:

```bash
compileI18n compileKeys <input> <output>

compile I18n yaml files to importable TS bundle

Positionals:
  input   root YAML input file path                          [string] [required]
  output  output TS bundle file path                         [string] [required]

Options:
      --version   Show version number                                  [boolean]
  -d, --dev                                           [boolean] [default: false]
  -?, -h, --help  Show help                                            [boolean]

Not enough non-option arguments: got 1, need at least 2
```

Moreover, for the sake of larger projects, keys can be split into multiple files. Consider the example:

```javascript
const localeKeys = {
	home: {
		welcome: "home.welcome",
		mainPanel: {
			text1: "home.mainPanel.text1",
			text2: "home.mainPanel.text2",
		},
	},
	login: {
		heading: "login.heading",
		buttons: {
			signIn: "login.buttons.signIn",
			register: "login.buttons.register",
		},
	},
};
```

To simplify the definition and maintain readability, the structure can be split into three files:

_entrypoint.yaml_

```yaml
home: !include(./home.yaml)
login: !include(./login.yaml)
```

_home.yaml_

```yaml
- welcome
- mainPanel:
      - text1
      - text2
```

_login.yaml_

```yaml
- heading
- buttons:
      - signIn
      - register
```

---

## Compatibility

TS files generated by the CLI with `compileKeys` are compatible with [react-i18next](https://react.i18next.com/).

---

## Unit tests

This project uses `jest` accompanied by `ts-jest` for unit testing. You can run all tests using `npm test`.

## Documentation

This project uses `jsdoc` to compile documentation to HTML files to `docs` directory. You can run the process with `npm run genDocs`. The docs will be written to `docs/i18n-plus/X.X.X`, and the only manual requirement is to put a proper entry to line $10$ in `docs/index.html`: `const VERSIONS = [..., "X.X.X"];`.

## Changelog

The changelog is available on [github](https://github.com/artus9033/i18n-plus/blob/master/CHANGELOG.md) and is auto-generated by `auto-changelog`, available as a script: `npm run changelog`.


text:
# Serving arbitrary web resources

Example of how to serve web resources like html files, js, css and images through Kalix via http.

Please look at the [documentation](https://docs.kalix.io/java-protobuf/serving-web-resources.html) for more details.

## Building and running unit tests

To compile and test the code from the command line, use

```shell
sbt test
```

## Running Locally

When running a Kalix service locally, we need to have its companion Kalix Proxy running alongside it.

To start your service locally, run:

```shell
sbt runAll
```

This command will start your Kalix service and a companion Kalix Proxy as configured in [docker-compose.yml](./docker-compose.yml) file.

For further details see [Running a service locally](https://docs.kalix.io/developing/running-service-locally.html) in the documentation.

## Exercise the service

With both the proxy and your service running, any defined endpoints should be available at `http://localhost:9000`. In addition to the defined gRPC interface, each method has a corresponding HTTP endpoint. Unless configured otherwise (see [Transcoding HTTP](https://docs.kalix.io/java-protobuf/writing-grpc-descriptors-protobuf.html#_transcoding_http)), this endpoint accepts POST requests at the path `/[package].[entity name]/[method]`. For example, using `curl`.

## Deploying

To deploy your service, install the `kalix` CLI as documented in
[Setting up a local development environment](https://docs.kalix.io/setting-up/)
and configure a Docker Registry to upload your docker image to.

You will need to set the `docker.username` system property when starting sbt to be able to publish the image, for example `sbt -Ddocker.username=myuser Docker/publish`.

If you are publishing to a different registry than docker hub, you will also need to specify what registry using the system property `docker.registry`.

Refer to
[Configuring registries](https://docs.kalix.io/projects/container-registries.html)
for more information on how to make your docker image available to Kalix.

Finally, you can use the [Kalix Console](https://console.kalix.io)
to create a Kalix project and then deploy your service into it
through the `kalix` CLI.

repository: lightbend/kalix-jvm-sdk

gha_language: Scala

repo_name: lightbend/kalix-jvm-sdk


text:
# Naming Standards for Dev, Test, Prod and Training dbt Environments

## Historical Naming Approach for Dev and Prod dbt Datasets

Historically, RA analytics engineers followed these standards when developing dbt projects:

Production. development and test BQ datasets were all in the same GCP project

The production dataset was named ```analytics``` and the only user that could write to it was the dbt GCP service account, via dbtCloud (e.g<EMAIL_ADDRESS>
Development took place in a shared dev dataset called ```analytics_dev``` that all developers/users could write to

Test/Staging was done through dbtCloud’s CI/CD test pipeline, that created temporary (as in, deleted automatically by dbtCloud) BQ datasets named in the format ```sinter_pr_xxxx_xx``` with ```xxxx_xx``` reflecting the pull request (PR) number that triggered the test pipeline build.

Note that these test/staging CI/CD temporary datasets are always created in the same GCP project that dbtCloud deploys the analytics dataset to, so consider this as pre-production final deployment testing.

## Dataset Names used by the RA DW dbt Framework

Our dbt DW framework expanded the number of datasets used for an environment from one (“analytics”) to four, to separate out database objects used for data transformation and process logging from the tables end-users were going to query:

- ``analytics``, the dataset used by end-users and Looker - think of this as the “base” dataset for their dbt environment

- ``analytics_staging``, a dataset containing SQL views and tables used in the data transformation process

- ``analytics_seed``, a dataset containing tables of reference and lookup data populated from files within the dbt project

- ``analytics_logs``, a dataset that contains audit, profile and logging tables created during data loads

Note that all of these datasets are automatically created in BigQuery on first run of the dbt DW framework, as long as the GCP service account used by the developer or dbtCloud has the BigQuery Admin role granted.

For an individual dbt developer, their “base” dataset is determined by the dataset configuration setting in their profiles.yml file

```
ra_data_warehouse:
  outputs:
    dev:
      type: bigquery
      method: service-account-json
      project: ra-development
      dataset: analytics_dev
```

### Development Environment(s) Naming

As a developer (as opposed to being dbtCloud), our team should use analytics_dev as their dataset value in the profiles.yml configuration file, which would lead to the following dataset names being created on first run of their dbt project:

- ``analytics_dev``

- ``analytics_staging_dev``

- ``analytics_seed_dev``

- ``analytics_logs_dev``

This, combined with developing in [git feature branches](https://github.com/rittmananalytics/ra_data_warehouse/blob/master/docs/git_branch_development.md), works out fine for single-developer projects.

However if there are multiple developers working on the project (note - not doing training exercises), dbt can be configured to use a schema prefix (e.g. “mark”, “lewis”, the developer’s first name) by setting an environment variable before running any of the dbt CLI tools, see the [doc notes on how this works](https://github.com/rittmananalytics/ra_data_warehouse/blob/master/docs/setup.md#cli-steps).

```
export schema_prefix=mark
```

This will thereafter instruct dbt to create dataset names, for individual developer environments, named like this:

- ``mark_analytics_dev``

- ``mark_analytics_staging_dev``

- ``mark_analytics_seed_dev``

- ``mark_analytics_logs_dev``

This approach of having a separate dev environment for each developer aligns with the development environment naming approach used by the [dbtCloud IDE](https://docs.getdbt.com/docs/running-a-dbt-project/using-the-dbt-ide/#setting-up-developer-credentials).

### Training Environment(s) Naming

For training environments (defined as dbt development not directly related to the development or maintenance of project feature branches), the developer should create an additional project (environment) definition in their profiles.yml configuration file, separate to the analytics_dev project definition, and use analytics_trn as the base dataset name. Combined with setting a schema_prefix environment variable set to their first name, this should lead to datasets being created like this for training purposes:

- ``mark_analytics_trn``

- ``mark_analytics_staging_trn``

- ``mark_analytics_seed_trn``

- ``mark_analytics_logs_trn``

Separation of Production, Development and Training Datasets
Optionally, these production, pre-prod testing/staging, dev and training datasets can be created in their own GCP projects with developer write access restricted to the development and training GCP projects.


text:
---
layout: post
title: C.S. Lewis on Membership vs. Collectivism
tags: summary, christianity
---

*C.S. Lewis read "Membership" on February 10, 1945 to the Society of St. Alban and St. Sergius, Oxford. I read it in the complication of his papers, The Weight of Glory. This is a summary and outline of the main points. All quotes are from the lecture unless otherwise noted.*

## Summary

The Christian life is not a private affair. But how can the Christian life at once reject individualism and yet counteract the secular notion of collectivism? The answer, Lewis says, is to consider the difference between Christian membership and secular collectivism.  Second, the body of Christ is eternal, whereas other collective bodies (e.g., clubs, societies, nations, etc...) are temporal.

## Outline

**"the idea that religion belongs to our private life—that it is, in fact, an occupation for the individual’s hour of leisure—is at once paradoxical, dangerous, and natural."**

> It is paradoxical because this exaltation of the individual in the religious field springs up in an age when collectivism is ruthlessly defeating the individual in every other field.

> But it is also dangerous for two reasons. In the first place, when the modern world says to us aloud, “You may be religious when you are alone,” it adds under its breath, “and I will see to it that you never are alone.”

> In the second place, there is the danger that real Christians who know that Christianity is not a solitary affair may react against that error by simply transporting into our spiritual life that same collectivism which has already conquered our secular life.

> though the private conception of Christianity is an error, it is a profoundly natural one... As personal and private life is lower than participation in the Body of Christ, so the collective life is lower than the personal and private life and has no value save in its service.

**"A consideration of the differences between the secular collective and the mystical body is... the first step to understanding how Christianity without being individualistic can yet counteract collectivism."**

Individuals members are not interchangeable in the Body of Christ as they are in a collective

> By members ([Greek]) Paul meant what we should call organs, things essentially different from, and complementary to, one another, things differing not only in structure and function but also in dignity.

> How true membership in a body differs from inclusion in a collective may be seen in the structure of a family. The grandfather, the parents, the grown-up son, the child, the dog, and the cat are true members (in the organic sense), precisely because they are not members or units of a homogeneous class. They are not interchangeable.

**"artificial equality is necessary in the life of the State, but... in the Church we strip off this disguise, we recover our real inequalities"**

Political equality is necessary because of the fall:

> since we have learned sin, we have found, as Lord Acton says, that "all power corrupts, and absolute power corrupts absolutely." The only remedy is to take away the powers and substitute a legal fiction of equality... the function of equality is purely protective.

But it is artificial, even if considered purely in secular terms.

> If value is taken in a worldly sense - if we mean that all men are equally useful or beautiful or good or entertaining - then it is nonsense.

This is not how we were made to live.

> [Equality] is medicine, not food... But it is not on this what we were made to live... Equality is a quantitative term and therefore love often knows nothing of it. Authority exercised with humility and obedience accepted with delight are the very lines long which our spirits live.

**"That structural position in the Church which the humblest Christian occupies is eternal and even cosmic"**

> There will come a time when every culture, every institution, every nation, the human race, all biological life is extinct and every one of us is still alive. Immortality is promised to us, not to these generalities. It was not for societies or states that Christ died, but for men.

**"Christianity cuts across the antithesis between individualism and collectivism"**

> [Christianity] sets its face relentlessly against our natural individualism; on the other hand, it gives back to those who abandon individualism an eternal possession of their own being, even of their bodies.


text:
### Borda Count

[Borda Count](https://www.electoral-reform.org.uk/voting-systems/types-of-voting-system/borda-count/) is a voting technique generally used in elections but rarely used in ensemble voting. This Jupyter notebook takes 4 datasets and observes the performance of Borda Count over Majority Voting.

### Results

![img](results.png)

path: /Borda Count/README.md


text:
# RatingBars

React UI component to show ratings.

## Getting Started

```
npm install react-ratingbars
```

Then simply include it in your project!

### Run the example

In root directory:

```
npm install
```

Then run the web dev server:

```
npm run start
```

As the output suggests you will be able to access the examples on localhost:3000

![alt text](https://raw.githubusercontent.com/anderslatif/ratingbars/master/examples/example.png)

## Authors

Anders Latif

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: anderslatif/RatingBars

repo_name: anderslatif/RatingBars


text:
To play enter your name.  To play the computer enter the name "COMP" in the player field.  Points accumulate as you roll the dice, however, if you roll a 1 you lose the points for your current turn and it's the next players turn.  First player to 100 wins._

## Setup/Installation Requirements

* _Clone to local machine and open index.html in the browser_

_To explore the source code, feel free to browse on github or clone to your local machine_

## Known Bugs

_game doesn't have a tie handler_

## Support and contact details

_Any issues or concerns, please email<EMAIL_ADDRESS>or<EMAIL_ADDRESS>
## Technologies Used

_HTML, CSS, Bootstrap, jQuery, JavaScript_

### License

*This software is available under the MIT License*

Copyright (c) 2019 **_Liam Kenna, Casey Idsinga_**

repository: LiamPKenna/pig-dice

repo_name: LiamPKenna/pig-dice


text:
# Hidden From HN
Outputs links that were hidden (through flagging, downvoting, or moderator action) from Hacker News

It seems to function pretty well, but you'll need to tweak the `consideredOld` and `notEnoughPointsPerHour` variables to accommodate changes in the HN user base over time.

repository: benwasser/hidden-from-hn

repo_name: benwasser/hidden-from-hn


text:
---
title: How to Make Homemade French Fries
date: 2017-09-02 10:46:00 Z
categories:
- snacks
tags:
- potatoes
- chaat masala
layout: post
author: admin
description: How to make french fries, french fries recipe, easiest french fries,
  how to make perfect french fries, french fries recipe at home, crispy french fries.
keywords: How to Make Homemade French Fries
---

How to Make Homemade French Fries

French fries are one of the most delicious famous snack that everyone loves to eat. Learn how to make french fries at home.
![How to Make Homemade French Fries]({{site.img_url}}/2017/09/homemade-yummy-french-fries-recipe.jpg)

Ingredients

Potatoes- 500 gm

oil for frying

salt to taste or 1/2 tbsp

Chaat masala

For Garnish

Finely chopped fresh coriander leaves

Method

Follow below easy steps to make yummy homemade Fries:

Firstly, peel the potatoes and wash it properly. Cut these peeled potatoes in rectangular long pieces. (You can use French fries cutter which is easily available in market, this cutter help you to cut French fries in equal shapes).

Now, put these potatoes in water so that potatoes does not fall dark.

Put these potatoes into water for minimum 5 minutes.

Now, boil this. Put salt in this water and boil it till it becomes soft.

When potatoes becomes soft, takes out from water. Wipe excess water with the help of cloth.

Now put the fries(potatoes) in the freezer for 10 minutes.

Take a pan, add oil and heat it up.

When oil is heated, add the fries in it and fry it lightly.

Take the fries out form pan and let them cool for 2 minutes..

Again, put these lightly fried potatoes in hot oil and fry them till becomes light brown.

French fires is ready.

Sprinkle chaat masala over it and garnish with fresh chopped coriander leaves.

Serve it with sauce...

extension: markdown


text:
# What is this?

Accessibilty Testing for PDF's ie. Tags Listing, Headings, Contents, invalid links and many more.
Fixed all the issued PDFs automatically.

# Usage

Clone.

Then...

```
Install Adobe Acrobat DC and UiPath.

STEPS TO FOLLOW :
- Please please update the path containing "FinalSubmission_1.1.xml" in PDFBOT.bat file carefully with '\\' as separators
- Place PDFs to Test in the "~\Parent" folder(should only contains PDF files)
- Make sure the PDFs last time opened in Adobe is closed after closing Tags Panel
- Please DON'T disturb XAML files, as they are sensitive
- Please, Launch the batch file named "PDF_BOT" placed on the desktop, in order to launch the process

------------Results are stored in the text file after successful execution--------

RESULT FILE :- "~\RESULT_FOLDER\"filename.txt" "
FIXED FILE :- "~\FIXED_PDFS\pdffile"
```


text:
### [CVE-2018-8469](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-8469)
![](https://img.shields.io/static/v1?label=Product&message=Microsoft%20Edge&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Elevation%20of%20Privilege&color=brighgreen)

### Description

An elevation of privilege vulnerability exists in Microsoft Edge that could allow an attacker to escape from the AppContainer sandbox in the browser, aka "Microsoft Edge Elevation of Privilege Vulnerability." This affects Microsoft Edge. This CVE ID is unique from CVE-2018-8463.

### POC

#### Reference
- https://www.exploit-db.com/exploits/45502/

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
---
layout: article
title: Notes
key: page-notes
permalink: /notes/
comment: false
---

Here are some of the notes I've written. Unless otherwise stated, all of these are works
in progress.

* [Notes on connections on principal bundles](/assets/docs/notes/principal-connections.pdf), and [exercises.](/assets/docs/notes/pc-exercises.pdf)
* [My Master's Thesis](/assets/docs/notes/seiberg-witten.pdf) in Seiberg-Witten Theory and the intersection form. I guess it's finished but ah, I wish I could've written so much more.


text:
RoosterJS
=========

Image, iframe, script lazy-loader with options such as pixel density for high resolution images

Docs & example at http://codepen.io/clearwavedesigns/pen/LFGhd.

repository: depthdev/RoosterJS

repo_name: depthdev/RoosterJS


text:
# tinyfpga-b2-first-project

My first project based on TinyFPGA B2. It simply blinks with an LED connected to
the pin 13.

Please note that beside of IceStorm you have to install the tinyfpgab script:

```
sudo pip2 install tinyfpgab
```

**Hint:** After pulling the board out of PC and plugging it back you need to
execute `tinyfpgab -b` once or twice to load the last configuration. When
plugging the board into a power bank the last configuration will be loaded
automatically.

Recommended tutorials:

* [Open FPGA Verilog Tutoral][t1]
* [Go Board Tutorials][t2]

[t1]: https://github.com/Obijuan/open-fpga-verilog-tutorial/wiki
[t2]: https://www.nandland.com/goboard/index.html


text:
# Emotiq Development Memo 004 --  The Emotiq Quicklisp distribution

Producing reliable software depends on have a reliable and exact
versioning of dependencies.

We use ASDF3 to package our software into ASDF systems, declaring
dependencies between these systems.  Although there is support within
ASDF for requiring a specific version or versions of a dependent
system, we currently do not use this mechanism, depending instead upon
Quicklisp to install the required version to the file-system.

In common usage, the term Quicklisp is overloaded with two meanings,
one being the software itself, but it also refers to a specific,
global version of the dependencies managed by Quicklisp.  This second
meaning is more properly known as the `quicklisp` dist.  In this
document we use `Quicklisp` to refer to the software, and `quicklisp`
to refer to the Quicklisp provided distribution.

For dependencies not in the `quicklisp` dist or which need a version
different than provided in Quicklisp, we use an `emotiq` Quicklisp
distribution.

## Current versions

Development currently relies on two Quicklisp distributions.

### `quicklisp`

    http://beta.quicklisp.org/dist/quicklisp/2018-01-31/distinfo.txt

### `emotiq`

    http://s3.us-east-1.amazonaws.com/emotiq-quickdist/emotiq.txt

## Developer best practices

The current practice for a developer on installing a new development instance of
development follow the following steps.  Afterwards, the
`ql:quickload` form will install the correct dependency.

### 1. Install Quicklisp

### 2. Pin the `quicklisp` distribution:
```lisp
(ql-dist:install-dist "http://beta.quicklisp.org/dist/quicklisp/2018-01-31/distinfo.txt" :replace t)
```

### 3. Install the `emotiq` distribution:
```lisp
(ql-dist:install-dist "http://s3.us-east-1.amazonaws.com/emotiq-quickdist/emotiq.txt")
```

### 4. Make sure `emotiq` distribution takes precedence:
```lisp
(setf (ql-dist:preference (ql-dist:dist "emotiq"))
      (1+ (ql-dist:preference (ql-dist:dist "quicklisp"))))
```

# Limitations

## Previous versions of the  `emotiq` distribution are not available

The `quickdist` tool does not produce enough meta-data information to
rollback the `emotiq` to a specific version, so we currently only have
a "latest" implementation.

Fixing this will require a better understanding of the machinery
involved in getting this form to return something meaningful.
```lisp
(ql-dist:available-versions (ql-dist:dist "emotiq"))
```

## Producing `emotiq` dist requires ccl

`lwpro` cannot currently use the `quickdist` tools to create a new
`emotiq` dist,  bombing out in an error about not being able to use
`system:run-program` on synonym streams.

`quickdist` is not smart enough to decipher reader conditionals
correctly, so using `sbcl` to produce the `emotiq` quickdist results
in `ironclad` referring to `sb-posix` and other `sbcl` optimized
internals.

For the time being, we use `ccl` to produce the `emotiq` dist.
Code for producing `emotiq-quickdist` is located here https://github.com/emotiq/research/tree/master/src/quickdist

## The "last" dist installed wins

For systems that occur in more than one distribution, Quicklisp has a
customizable preference mechanism for picking which which one
`ql:quickload` wins.  By default, the temporally latest installed
distribution "wins".  We currently rely on this mechanism, so it is
important to "pin" the `quicklisp` installation to a specific version
before installing the `emotiq` distribution.

# References

See <http://blog.quicklisp.org/2011/08/going-back-in-dist-time.html>
for more information.

# Implementation

Uploading to S3: <https://github.com/emotiq/emotiq-quickdist>

# Colophon

    Mark Evenson<EMAIL_ADDRESS>    Created: 09-MAR-2018
    Revised: <2018-06-11T14:45:30Z>

repository: easye/emotiq-quickdist

repo_name: easye/emotiq-quickdist


text:
# SwiftSyntaxHighlighter

![CI][ci badge]
[![Documentation][documentation badge]][documentation]

A syntax highlighter for Swift code that uses
[SwiftSyntax](https://github.com/apple/swift-syntax).
You can use it either from the command-line,
via the `swift-highlight` executable,
or in Swift code using the `SwiftSyntaxHighlighter` module.

This functionality is discussed in the NSHipster article
[SwiftSyntax](https://nshipster.com/swiftsyntax/).

## Requirements

- Swift 5.3+

## Command-Line Usage

The `swift-highlight` executable can be run from the command line
to highlight either a path to a source file or source code:

```terminal
$ swift highlight 'print("Hello, world!")'
<pre class="highlight"><code><span class="keyword">let</span> <span class="variable">greeting</span> = <span class="string literal">"</span><span class="string literal">Hello, world!</span><span class="string literal">"</span></code></pre>
```

Pass the `--scheme pygments` option
to generate [Pygments](http://pygments.org)-compatible HTML:

```terminal
$ swift highlight 'print("Hello, world!")' --scheme pygments
<pre class="highlight"><code><span class="n">print</span><span class="p">(</span><span class="p">"</span><span class="s2">Hello, world!</span><span class="p">"</span><span class="p">)</span></code></pre>
```

`swift-highlight` also accepts arguments piped from standard input (`stdin`):

```terminal
echo 'print("Hello, world!")' | swift highlight
<pre class="highlight"><code><span class="variable">print</span>(<span class="string literal">"</span><span class="string literal">Hello, world!</span><span class="string literal">"</span>)
</code></pre>
```

### Installation

#### Homebrew

Run the following command to install using [homebrew](https://brew.sh/):

```terminal
$ brew install nshipster/formulae/swift-syntax-highlight
```

#### Manually

Run the following commands to build and install manually:

```terminal
$ git clone https://github.com/NSHipster/SwiftSyntaxHighlighter.git
$ cd SwiftSyntaxHighlighter
$ make install
```

## Code Usage

`SwiftSyntaxHighlighter` provides type methods named `highlight`
that take either
source code as a `String`,
a source file `URL`,
or a `SourceFileSyntax` AST created by SwiftSyntax.

```swift
import SwiftSyntaxHighlighter

let code = """
print("Hello, world!")
"""

let html = try SwiftSyntaxHighlighter.highlight(source: source, using: Xcode.self)
```

After running this code,
`html` contains the following string:

```
<pre class="highlight"><code><span class="keyword">let</span> <span class="variable">greeting</span> = <span class="string literal">"</span><span class="string literal">Hello, world!</span><span class="string literal">"</span></code></pre>
```

### Installation

#### Swift Package Manager

Add the SwiftSyntaxHighlighter package to your target dependencies in `Package.swift`:

```swift
import PackageDescription

let package = Package(
  name: "YourProject",
  dependencies: [
    .package(
        url: "https://github.com/NSHipster/SwiftSyntaxHighlighter",
        from: "1.2.0"
    ),
  ]
)
```

Then run the `swift build` command to build your project.

## License

MIT

## Contact

Mattt ([@mattt](https://twitter.com/mattt))

[ci badge]: https://github.com/NSHipster/SwiftSyntaxHighlighter/workflows/CI/badge.svg
[documentation badge]: https://github.com/NSHipster/SwiftSyntaxHighlighter/workflows/Documentation/badge.svg
[documentation]: https://github.com/NSHipster/SwiftSyntaxHighlighter/wiki


text:
---
title: Binding to DataTable
page_title: Binding to DataTable - WinForms ChartView Control
description: Learn how to bind WinForms ChartView to a DataTable.
slug: winforms/chartview-/populating-with-data/binding-to-datatable
tags: binding,to,datatable
published: True
position: 1
previous_url: chartview-databinding-binding-to-datatable
---

# Binding to DataTable

Binding to DataTable is quite easy with __RadChartView__. Once your table is created, you just need to set the needed members to the desired fields. In [this article]({%slug winforms/chartview-/populating-with-data%}) , you can find the members needed for the different series types.

Here is a sample demonstrating how to bind а [LineSeries]({%slug winforms/chartview-/series-types/line%}):

#### Binding to DataTable

{{source=..\SamplesCS\ChartView\DataBinding\ChartViewDataBindingToDataTable.cs region=binding}}
{{source=..\SamplesVB\ChartView\DataBinding\ChartViewDataBindingToDataTable.vb region=binding}}

````C#
DataTable table;
protected override void OnLoad(EventArgs e)
{
    base.OnLoad(e);
    table = new DataTable();
    table.Columns.Add("Value", typeof(double));
    table.Columns.Add("Name", typeof(string));
    table.Rows.Add(1, "John");
    table.Rows.Add(3, "Adam");
    table.Rows.Add(5, "Peter");
    table.Rows.Add(12, "Sam");
    table.Rows.Add(6, "Paul");
    LineSeries lineSeria = new LineSeries();
    radChartView1.Series.Add(lineSeria);
    lineSeria.ValueMember = "Value";
    lineSeria.CategoryMember = "Name";
    lineSeria.DataSource = table;
}

````
````VB.NET
Private table As DataTable
Protected Overrides Sub OnLoad(e As EventArgs)
    MyBase.OnLoad(e)
    table = New DataTable()
    table.Columns.Add("Value", GetType(Double))
    table.Columns.Add("Name", GetType(String))
    table.Rows.Add(1, "John")
    table.Rows.Add(3, "Adam")
    table.Rows.Add(5, "Peter")
    table.Rows.Add(12, "Sam")
    table.Rows.Add(6, "Paul")
    Dim lineSeria As New LineSeries()
    RadChartView1.Series.Add(lineSeria)
    lineSeria.ValueMember = "Value"
    lineSeria.CategoryMember = "Name"
    lineSeria.DataSource = table
End Sub

````

{{endregion}}

>caption Figure 1: Binding to DataTable
![WinForms RadChartView Binding to DataTable](images/chartview-databinding-binding-to-datatable001.png)

Adding, removing or modifying a record in the DataTable is automatically reflected in __RadChartView__:

>caption Figure 2: Modify Item
![WinForms RadChartView Modify Item](images/chartview-databinding-binding-to-datatable002.png)

# See Also

* [Getting Started]({%slug winforms/chartview/getting-started%})
* [Binding to BindingList]({%slug winforms/chartview-/populating-with-data/binding-to-bindinglist%})

repository: telerik/winforms-docs

repo_name: telerik/winforms-docs


text:
pyfastcopy
==========

[![Latest version](https://img.shields.io/pypi/v/pyfastcopy.svg?style=flat)](https://pypi.python.org/pypi/pyfastcopy/)
[![Tests status](https://img.shields.io/travis/desbma/pyfastcopy/master.svg?label=tests&style=flat)](https://travis-ci.org/desbma/pyfastcopy)
[![Coverage](https://img.shields.io/coveralls/desbma/pyfastcopy/master.svg?style=flat)](https://coveralls.io/github/desbma/pyfastcopy?branch=master)
[![Supported Python versions](https://img.shields.io/pypi/pyversions/pyfastcopy.svg?style=flat)](https://pypi.python.org/pypi/pyfastcopy/)

[ **This project is no longer maintained, as Python 3.8 will include similar [copy speedup builtin](https://bugs.python.org/issue33671).** ]

pyfastcopy is a simple Python module that monkey patches the `shutil.copyfile` function of Python standard library to internally use the sendfile system call.

It can provide important performance improvements for large file copy (typically 30-40%). See [the performance section](#performance) for some numbers.

Because `shutil.copyfile` is used by other fonctions in the `shutil` module, the following functions also automatically benefit from the performance boost:

* `shutil.copy`
* `shutil.copy2`
* `shutil.copytree`

If `sendfile` is not available on your system or fails, the classic, slower chunk file copy is used, so there is no downside to using this module.

For more information, see [my proposed patch](https://bugs.python.org/issue25156) for Python.

## Performance

Tests were done copying files (source and destination) on a [tmpfs](https://en.wikipedia.org/wiki/Tmpfs) filesystem, so that no slowdown related to hard drive or SSD storage occurs. Test files were generated with pseudo random data using [frandom](http://www.billauer.co.il/frandom.html).

See [benchmark.py](https://github.com/desbma/pyfastcopy/blob/master/benchmark.py) for details about the test procedure and how the following graphs were generated.

Python 3.4: [![graph1](https://i.imgur.com/fbKbKgmt.png)](https://i.imgur.com/fbKbKgm.png) [![graph2](https://i.imgur.com/Cnrwi2Yt.png)](https://i.imgur.com/Cnrwi2Y.png) [![graph3](https://i.imgur.com/B3GDWFrt.png)](https://i.imgur.com/B3GDWFr.png)

Python 3.6: [![graph4](https://i.imgur.com/5lnETSCt.png)](https://i.imgur.com/5lnETSC.png) [![graph5](https://i.imgur.com/YsBWYsxt.png)](https://i.imgur.com/YsBWYsx.png) [![graph6](https://i.imgur.com/k32LSbCt.png)](https://i.imgur.com/k32LSbC.png)

**These tests show a 30-50% performance improvement of `shutil.copyfile` compared to stock Python.**

## Usage

Just import the module:

    import pyfastcopy

And then use the patched `shutil.copyfile` as usual:

    shutil.copyfile(src, dst)

**The `sendfile` system call does not exist on Windows, so importing this module will have no effect.**

## Installation

### From PyPI (with PIP)

1. If you don't already have it, [install pip](https://pip.pypa.io/en/stable/installing/) for Python 3 (not needed if you are using Python >= 3.4)
2. Install pyfastcopy: `pip3 install pyfastcopy`
3. Enjoy fast copy when using `shutil.copyfile`, `shutil.copy`, `shutil.copy2` or `shutil.copytree`

### From source

1. If you don't already have it, [install setuptools](https://pypi.python.org/pypi/setuptools#installation-instructions) for Python 3
2. Clone this repository: `git clone https://github.com/desbma/pyfastcopy`
3. Install pyfastcopy: `python3 setup.py install`
4. Enjoy fast copy when using `shutil.copyfile`, `shutil.copy`, `shutil.copy2` or `shutil.copytree`

## License

Python Software Foundation License

repository: desbma/pyfastcopy

repo_name: desbma/pyfastcopy


text:
# Week 5 - Odds and Sods

This week we covered some catchup around data analysis and visualization.  Our
examples were just getting us started with plotting volume and image data.

## Slides and Examples

The notebook `examples_week05.ipynb` is in this directory.


text:
#### Introduction

This ROS package provides a script and launch files for playing back old
annotated people tracking logfiles in CARMEN format, such as those found here (Freiburg City Center/Aspekt and Main Station):

[Annotated 2D laser datasets (Social Robotics Labs, University of Freiburg)](http://www2.informatik.uni-freiburg.de/~luber/people_tracker/logfiles/logfiles.html)

#### Usage

The script publishes the following topics for each available sensor:

- `sensor_msgs/LaserScan` with the original laser scan data
- `srl_laser_segmentation/LaserscanSegmentation` with the annotations (each laser endpoint is labelled with an integer label, corresponding to the track ID)
- `sensor_msgs/Image`, if a camera was used during recording and the corresponding .bin file is present in the same directory

The `srl_laser_segmentation/LaserscanSegmentation` messages can be converted into `spencer_tracking_msgs/TrackedPersons` via the following command-line
(note you might have to rename the input and output topics properly, check `rostopic list` and `rosnode info` on the involved ROS nodes):

   rosrun srl_laser_segmentation segmentation_to_tracks.py

The resulting `TrackedPersons` messages can then, for instance, be used as a groundtruth input to `spencer_tracking_metrics`.

##### Credits

©2014-2015 Timm Linder, Social Robotics Laboratory, University of Freiburg


text:
srg52x-docker
===

SRG-3352x docker container for developement applications

1. to install docker.io, please reference [this article](https://docs.docker.com/engine/install/ubuntu). And to add your account into docker group and launch docker

    > sudo groupadd docker \# for create docker group
    >
    > sudo usermod -aG docker \<your account\> \# add your account into docker group
    >
    > sudo systemctl enable docker
    >
    > sudo systemctl start docker
    >
    > sudo reboot \# reminds: please reboot the host

2. install qemu-user-static

    > a. apt update
    >
    > b. apt install qemu-user-static binfmt-support binfmt-misc
    >
    > c. update-binfmts --enable qemu-arm

3. clone this repository on your local development host

    > git clone https://github.com/AaeonIot/srg52x-docker.git

4. build the docker image

    > cd srg52x-docker
    >
    > ./build_container.sh # the step will build a docker image on local host and create ./works folder for place your source code

5. run the docker image for your application development,

    > ./run_container.sh  # the step will start a container