text:
### React Implementation and Concepts

#### Resources

- **React Team core Notes**
  https://github.com/reactjs/core-notes
  Notes from the React team's weekly-ish meetings

#### Core Concepts

- **React Components, Elements, and Instances**
  https://medium.com/@dan_abramov/react-components-elements-and-instances-90800811f8ca
  Clarifies the differences between these related terms.

- **React Elements vs React Components vs Component Backing Instances**
  https://medium.com/@fay_jai/react-elements-vs-react-components-vs-component-backing-instances-14d42729f62
  Another solid comparison of what these terms mean, how React uses them, and how they differ.

- **React - Basic Theoretical Concepts**
  https://github.com/reactjs/react-basic
  React team member Seb Markbage dives into his mental model for how React works.  (Note: after the first few paragraphs, _not_ "basic" at all.  Definitely an involved read, but informative.)

- **Our First 50,000 Stars**
  https://facebook.github.io/react/blog/2016/09/28/our-first-50000-stars.html
  A post celebrating React's progress, including a history of how React's concepts came together over time

- **React Elements vs React Components**
  https://tylermcginnis.com/react-elements-vs-react-components/
  An explanation of how elements represent DOM nodes, what `createElement` does, and how components and rendering relate to elements

#### Miniature React Implementations

- **Building React from Scratch**
  https://www.youtube.com/watch?v=_MAD4Oly9yg
  Paul O'Shannessy walks through building a mini React implementation

- **Building Your Own React Clone in Five Easy Steps**
  http://blog.javascripting.com/2016/10/05/building-your-own-react-clone-in-five-easy-steps/
  Builds a mini-React implementation to illustrate the basic principles

- **Reverse Engineering React**
  https://vimeo.com/album/3930691
  A video series covering the implementation of an alternative/miniature version of React called "Reaction".  Note that it doesn't look at React itself, but does cover all the equivalent concepts in a simpler implementation.

- **Tiny React Reimplementation**
  http://jsbin.com/qiguyibolu/1/edit?js,output
  A _very_ tiny (100 lines) implementation of React's basic algorithm

- **Tiny React Renderer**
  https://github.com/iamdustan/tiny-react-renderer
  A heavily commented learning implementation of a bare basic React renderer

- **How to write your own Virtual DOM**
  https://medium.com/@deathmood/how-to-write-your-own-virtual-dom-ee74acc13060
  https://medium.com/@deathmood/write-your-virtual-dom-2-props-events-a957608f5c76
  A series of articles that build up a small Virtual DOM system from scratch.

- **Write Your Own React.js!**
  https://medium.com/@calebmer/write-your-own-react-js-776dbef98b8
  Some thoughts on why and how you might want to try writing your own React-alike, and some of the tradeoffs involved in writing something like React.

- **Didact: Learning how React works by building it from scratch**
  https://engineering.hexacta.com/didact-learning-how-react-works-by-building-it-from-scratch-51007984e5c5
  https://engineering.hexacta.com/didact-element-creation-and-jsx-d05171c55c56
  https://engineering.hexacta.com/didact-rendering-dom-elements-91c9aa08323b
  https://engineering.hexacta.com/didact-instances-reconciliation-and-virtual-dom-9316d650f1d0
  https://engineering.hexacta.com/didact-components-and-state-53ab4c900e37
  https://engineering.hexacta.com/didact-fiber-incremental-reconciliation-b2fe028dcaec
  An ongoing series of articles showing how to build parts of React's API and implementation, like `createElement`, `setState`, and the "Fiber" reconciliation approach.

- **deact: React under the hood**
  https://github.com/lukebelliveau/deact
  A repository for learning about how React works internally.  Has a link to a slide set that explains the concepts, and has branches for the various lessons.

- **React Internals**
  http://www.mattgreer.org/articles/react-internals-part-one-basic-rendering/
  http://www.mattgreer.org/articles/react-internals-part-two-componentWillMount-and-componentDidMount/
  http://www.mattgreer.org/articles/react-internals-part-three-basic-updating/
  http://www.mattgreer.org/articles/react-internals-part-four-setState/
  A 5-part series that will recreate React from the ground up, illustrating how it works along the way.

- **Making a custom React renderer**
  https://github.com/nitin42/Making-a-custom-React-renderer
  A 4-part that teaches how to build a React reconciler for React 16 that renders to a Word document

- **Extending React**
  https://www.javascriptjanuary.com/blog/extending-react
  Walks through building a very simplified mini React clone, including `createElement`, rendering to the DOM, and `setState` updates

#### Implementation and Internals

- **React.js Reconciliation**
  https://www.infoq.com/presentations/react-reconciliation
  A video presentation digging into how React's reconciliation algorithm determines how to properly update nodes based on render output.

- **React Source Code Annotations**
  https://annot.io/github.com/facebook/react
  Crowdsourced annotations and descriptions for files in the React codebase

- **ReactJS: Under the Hood**
  https://www.youtube.com/watch?v=xsKYAa1ZXpQ
  A talk digging into React's internal concepts and implementation, including the split between the core library and the renderers.

- **React Implementation Notes**
  https://facebook.github.io/react/contributing/implementation-notes.html
  An in-depth explanation of how React's current internal algorithms work

- **Dive Into React Codebase: Transactions**
  http://reactkungfu.com/2015/12/dive-into-react-codebase-transactions/
  A deep dive into the implementation of React's internal "transactions" concept

- **React Events In Depth**
  https://www.youtube.com/watch?v=dRo_egw7tBc
  A Javascript Air episode focused on how React's Events system works, with React team members Dan Abramov and Ben Alpert

- **Dive Into React Codebase: Handling state changes**
  http://reactkungfu.com/2016/03/dive-into-react-codebase-handling-state-changes/
  A deep dive into how React implements component state and `setState()`

- **On the Async Nature of `setState` in React**
  http://thereignn.ghost.io/on-the-async-nature-of-setstate-in-react/
  Digs into the behavior of `setState`, and whether it is actually always async or not.  Some decent info, although the final section does make some strange statements.

- **setState() State Mutation Operator May Be Synchronous in ReactJS**
  https://www.bennadel.com/blog/2893-setstate-state-mutation-operation-may-be-synchronous-in-reactjs.htm
  Digs into the behavior of React's setState method, and discusses when it may be synchronous vs asynchronous

- **React Internals: Through the Lens of a Renderer**
  https://www.youtube.com/watch?v=VVxQAoNK_XQ
  A talk exploring how a React renderer works, and how to implement a tiny renderer

- **Making custom renderers for React**
  http://goshakkk.name/react-custom-renderers/
  Describes techniques for building custom rendering components that bridge between normal rendering and something like a canvas

- **The Inner Workings of Virtual DOM**
  https://medium.com/@rajaraodv/the-inner-workings-of-virtual-dom-666ee7ad47cf
  An in-depth article that digs into how a Virtual DOM implementation works, using Preact as an example.  Includes some detailed flowcharts of their behavior.

- **React Internals**
  https://zackargyle.github.io/react-internals-slides/#/
  An informative slideshow that walks through many aspects of React's implementation and behavior, including rendering, reconciliation, setState, Fiber, and more, with helpful visualizations.

 - **Preact Internals**
   https://medium.com/@asolove/preact-internals-1-the-easy-parts-3a081fa36205
   https://medium.com/@asolove/preact-internals-2-the-component-model-36a05e32957b
   A series of posts that walk through the Preact codebase and explain its implementation, as well as the component model.

- **The React Source Code: A Beginner's Walkthrough**
  https://medium.com/@ericchurchill/the-react-source-code-a-beginners-walkthrough-i-7240e86f3030
  A long, detailed walkthrough of large parts of the React codebase

- **Preact: Into the void 0**
  https://youtu.be/LY6y3HbDVmg
  A talk by Jason Miller, author of Preact, covering some of the core implementation concepts behind Preact (and other virtual DOM/component libraries), as well as some important aspects for DOM manipulation performance.

- **Under the hood: ReactJS**
  https://bogdan-lyashenko.github.io/Under-the-hood-ReactJS/
  An incredibly detailed walkthrough of React's entire codebase and execution flow, with many diagrams and flowcharts illustrating things.  Very impressive.

- **Preact Internals**
  https://medium.com/@asolove/preact-internals-1-the-easy-parts-3a081fa36205
  https://medium.com/@asolove/preact-internals-2-the-component-model-36a05e32957b
  https://medium.com/@asolove/preact-internals-3-some-fiddly-little-bits-f353b1ad7abc
  A 3-part series that dives into the implementation and concepts of the Preact library codebase.

- **An Interview with the React Team About Wordpress and Project Gutenberg**
  https://wpcouple.com/interview-react-team-facebook-wordpress-gutenberg/
  A Wordpress community site interviews Dan Abramov, Andrew Clark, and Sophie Alpert about a variety of topics, including how they prioritize features, how React is tested, dealing with breaking changes, downsides of React, and aspects of Wordpress using React for its "Project Gutenberg" tool.

- **The React Story: How Facebook's Instagram Acquisition Led to the Open Sourcing of React**
  https://stackshare.io/posts/the-react-story
  An extensive podcast interview with Pete Hunt, former React team member, recounting his early work at Facebook, how he began using React at Instagram, how that led to the growth of React inside Facebook, and how the decision to open-source React happened.  Page includes a complete transcript of the discussion.

- **How exactly does React handle events?**
  https://levelup.gitconnected.com/how-exactly-does-react-handles-events-71e8b5e359f2
  A detailed look at how React's internal event handling works, including normalization of events, SyntheticEvent objects, and more.

- **A look inside React Fiber**
  http://makersden.io/blog/look-inside-fiber/
  Traces through the source code for React 16 / React Fiber, starting with the main `render()` function and diving down from there through the system.

- **Understanding the React Source Code**
  https://hackernoon.com/understanding-the-react-source-code-initial-rendering-simple-component-i-80263fe46cf1
  https://hackernoon.com/understanding-the-react-source-code-initial-rendering-simple-component-ii-79e7e8bed56c
  https://hackernoon.com/understanding-the-react-source-code-initial-rendering-simple-component-iii-69c2711c5f33
  https://hackernoon.com/understanding-the-react-source-code-iv-e3c4b66da12c
  https://hackernoon.com/understanding-the-react-source-code-v-812d69a79fb9
  Walks through the critical path of React 15's source code, tracing how a simple component gets rendered.

#### React Fiber

- **React v16.0**
  https://reactjs.org/blog/2017/09/26/react-v16.0.html
  The React team officially announces the release of React 16 and describes the new features, including returning arrays, error handling, better server-side rendering, and more.

- **React 16: A look inside an API-compatible rewrite**
  https://code.facebook.com/posts/1716776591680069/react-16-a-look-inside-an-api-compatible-rewrite-of-our-frontend-ui-library/
  The React team describes how they handled building and testing React 16 to be backwards compatible with existing code.

- **ReactConf 2017: A Cartoon Intro to Fiber**
  https://youtu.be/ZCuYPiUIONs
  A fantastic presentation by Lin Clark, explaining the core concepts and implementation of React Fiber with cartoon illustrations.

- **Roadmap for React - Fiber and Beyond**
  https://www.youtube.com/watch?v=QW5TE4vrklU
  A keynote by Andrew Clark, describing the ideas behind React Fiber and the benefits it will give.

- **React Fiber: A Closer Look at the New Engine of React**
  https://www.infoq.com/news/2017/05/react-fiber-closer-look
  A useful summary of the goals and implementation approach for the new React Fiber algorithm

- **Top Resources to Explore React Fiber**
  https://hackernoon.com/top-resources-to-explore-react-fiber-9a2b19114520
  A helpful list of links to further articles and resources for learning about React Fiber

- **React Fiber for the rest of us**
  http://www.benmvp.com/slides/2017/reactboston/fiber.html#/
  Slides from Ben Ilegbodu's ReactBoston presentation, which summarize the changes in React 16.

- **What's new in React 16?**
  https://www.robinwieruch.de/what-is-new-in-react-16/
  A very useful look at the new user-facing features in React 16, with code examples.

- **Rethinking with React 16**
  https://www.javascriptjanuary.com/blog/rethinking-with-react-16
  An informative overview of the major changes in React 16, including the goals of the "React Fiber" rewrite, Fragments, Error Boundaries, server-side rendering improvements, and more.

- **React Fiber Architecture**
  https://github.com/acdlite/react-fiber-architecture
  A description of React's new core algorithm, React Fiber

- **What's Next for React - React Fiber**
  https://www.youtube.com/watch?v=aV1271hd9ew
  Andrew Clark describes the concepts, implementation, and potential benefits of the in-progress React Fiber internal algorithm reimplementation.

- **React Fiber Resources**
  https://github.com/koba04/react-fiber-resources
  Links and info on the new React Fiber algorithm

- **Why, What, and How of React Fiber**
  https://www.youtube.com/watch?v=crM1iRVGpGQ
  Kent C Dodds interviews Dan Abramov and Andrew Clark about what React Fiber is intended to do, how it works, and what it means for the React codebase.

- **What is React Fiber?**
  https://giamir.com/what-is-react-fiber
  An overview of the React Fiber rewrite, and how React's reconciler has been rewritten to improve performance and make rendering more flexible.

repository: tied/DevArtifacts

repo_name: tied/DevArtifacts


text:
# capistrano-redmine

This gem contains a Capistrano :task, which allows to update the Redmine issues
statuses when you do deploy with Capistrano. For example, to change issues
status from "Waiting for deploy" to "Waiting for review."

## Installation

Add this line to your application's Gemfile:

    gem 'capistrano-redmine', :require => false

or

    gem 'capistrano-redmine', :git => 'git://github.com/foxweb/capistrano-redmine.git', :require => false

And then execute:

    $ bundle install

Or install it yourself as:

    $ gem install capistrano-redmine

## Usage

1. Install and config you [Capistrano](https://github.com/capistrano/capistrano/) utility.
2. Install _capistrano-redmine_.
3. Change directory to RAILS_ROOT of your app.
3. Add this variables in `config/deploy.rb`:

    ```ruby
      # settings for capistrano-redmine
      set :redmine_site, "http://localhost:3000" # Redmine app host and port
      set :redmine_token, "376ba30fca80867d10a0ec0b505e5c97834901e3" # Redmine API key
      set :redmine_options, {}
      set :redmine_projects, "test-project" # you project identifier or array of.
      set :redmine_from_status, 1 # Redmine status ID "from"
      set :redmine_to_status, 3 # Redmine status ID "to"
      require "capistrano-redmine"
    ```

    and

    ```ruby
      after "deploy", "redmine:update"
    ```

    Specify the necessary settings for your Redmine.

    If you want to use specific options of ActiveResource (some HTTP of SSL options), you can add the following settings. Specify `:ssl` options if you use HTTPS connection to Redmine. Specify `:proxy` URL if you use HTTP-proxy.

    ```ruby
      set :redmine_options, {
        :ssl => {
                :cert => OpenSSL::X509::Certificate.new(File.read("cert.pem")),
                :key  => OpenSSL::PKey::RSA.new(File.read("key.pem"))
              },
        :proxy => 'http://user:password@proxy.people.com:8080'
      }
    ```

4. Check installation with command

    `bundle exec cap -T redmine`

    You should see line:

    `cap redmine:update        # Update Redmine issues statuses.`

5. Start `bundle exec cap deploy` or `bundle exec cap redmine:update`.
6. Check your Redmine issues and enjoy it!

## Redmine API config

1. To enable the API-style authentication, you have to check Enable REST API in **Administration → Settings → Authentication**.
2. Create new user named like 'deploy' (or other) and login with this.
3. You can find your API key on your account page ( /my/account ) when logged in, on the right-hand pane of the default layout.
4. Copy and paste API key to the `config/deploy.rb` on `set :redmine_token`.

## Documentation

* [Capistrano Wiki](http://github.com/capistrano/capistrano/wiki/)
* [Redmine API](http://www.redmine.org/projects/redmine/wiki/Rest_api)

## Contributing

1. Fork it.
2. Create your feature branch (`git checkout -b my-new-feature`).
3. Commit your changes (`git commit -am 'Added some feature'`).
4. Push to the branch (`git push origin my-new-feature`).
5. Create new Pull Request.

license: MIT

repository: synbioz/capistrano-redmine

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: synbioz/capistrano-redmine


text:
# Hand of God - E16 Theme

Hello, I'm the original maintainer of this well known theme for Enlightenment window manager.

Back in the old days, Technoir created this theme for E13 to E15 if I recall correctly that it was not updated for E16.

I took over the maintainer of the theme and updated it for E16.

<img src="e16_hand_of_god.jpg" />

I think it will be much deserved to leave it up on here and please do fork, PR for improvements, or star this repo.

Happy times.

repository: craigbutcher/hand-of-god

repo_name: craigbutcher/hand-of-god


text:
# Sorter

[![Latest Release](https://img.shields.io/github/release/giantas/sorter.svg?maxAge=2592000)](https://github.com/giantas/sorter/releases/latest)
[![Issues](https://img.shields.io/github/issues-raw/giantas/sorter/website.svg)](https://github.com/giantas/sorter/issues)
[![Say Thanks](https://img.shields.io/badge/Say%20Thanks-!-blue.svg)](https://saythanks.io/to/giantas)

An application that organises/sorts files in a folder into folder-groups named by type. It (optionally) groups the folders created in the first sorting into categories as defined in [filegroups](filegroups.py)

## Download
[![SourceForge](https://img.shields.io/sourceforge/dm/file-sorter.svg)](http://file-sorter.sourceforge.io)
[![Github Latest Downloads](https://img.shields.io/github/downloads/giantas/sorter/latest/total.svg)](https://github.com/giantas/sorter/releases/latest)

Download from [Sorter - SourceForge](http://file-sorter.sourceforge.io)

For specific OS versions, go to [Sorter - Official Releases](https://github.com/giantas/sorter/releases/latest)

## Usage

Launch [Sorter GUI](releases/latest)

![main screen](screenshots/Screenshot_20170505_081019.png)

Choose source folder - folder in which files should be organised

![Choose source folder](screenshots/Screenshot_20170505_081200.png)

Choose destination folder - where the files will be moved to - not required.

Select any (or all) option(s) - sort folders; recursive; types:

	* Sort folder - groups the file type folders into categories of audio, video, etc.

	* Recursive - checks inside folders and their subfolders for any files and organises them relative to the source folder.

	* Type - allows a user to select specific file types/format to be organised/sorted.

![Choose option(s)](screenshots/Screenshot_20170505_081200.png)

![Types screen](screenshots/Screenshot_20170505_081054.png)

##### Note
If option 'types' is not checked, by default, all files will be organised/sorted.

##### Click Run

![Resulting groups of folders](screenshots/Screenshot_20170505_081300.png)

![Resulting folders organised by file type](screenshots/Screenshot_20170505_081329.png)

#### Alternatively - clone repo

*Do*

git clone https://github.com/giantas/sorter.git

cd sorter

then

```
python sorter.py
```

or

```
python3 sorter.py
```

Then follow the GUI steps listed above.

## Warning
You should have access (read) and *write* permissions on the source and destination folders.
*Be careful* not to use sorter on application folders. Sorter actions are *NOT* reversible (for now).

### Prerequisites
#### For the installer/binary [packages](releases/latest)
* None

#### For repo clone
* Python 3.x (3.4 recommended)

### Authors

* **[Giantas](https://github.com/giantas)**

### License

* This project is licensed under the BSD 3-clause "New" or "Revised" License - see the [LICENSE](LICENSE) file for details

### TODO

1. Add sorting by user provided parameter(s).
2. Add support for reversing actions.
3. Add expose function (to remove files from directories).

repository: iamsabrinab/sorter

repo_name: iamsabrinab/sorter


text:
# Blue Atom Syntax

This is a a special syntax design to code with [Blue Atom UI](https://github.com/emeric-martineau/blue-atom-ui).

This syntax is clear with few colors.

![Code screen](https://raw.githubusercontent.com/emeric-martineau/blue-atom-syntax/master/images/code-screen.png)

repository: emeric-martineau/blue-atom-syntax

repo_name: emeric-martineau/blue-atom-syntax


text:
# LeadScore

This library calculates a 'lead score', a simple score which gives you some indication that an email address is either associated with an influential individual, or a high profile company.

This score is especially useful for sales and marketing. For example, you could calculate scores for all your inbound sales inquires and also for existing customers, providing a good signal for valuable leads.

Behind the scenes, this library uses [Clearbit](https://clearbit.co), a data API which returns information on email addresses and company domain names. That information is then [used to calculate](https://github.com/maccman/clearbit-lead_score/blob/master/lib/clearbit/lead_score.rb#L53) a (fairly rudimentary) score taking into account such things as how many Twitter followers the person has, or if how much the company has raised, how many employees it has, etc.

Scores are out of `1.0`, where `1.0` is the highest and `0.0` the lowest (we didn't find any information).

## Getting started

Firstly you'll need an [Clearbit](https://clearbit.co) API key - register there and save your key. Clearbit provides 50 free lookups a month.

Then install the gem, `clearbit-leadscore`. A CLI is provided for simple email lookups.

    gem install clearbit-leadscore

    $ clearbit-leadscore
      Usage: clearbit-leadscore [options] email
          -k, --api-key                    Set API Key
          -h, --help                       Display this screen

    clearbit-leadscore --api-key CLEARBIT_KEY<EMAIL_ADDRESS>
There's also a Ruby API.

    Clearbit::LeadScore.key = ENV['CLEARBIT_KEY']

    result = Clearbit::LeadScore.lookup(email)

    if result
      puts "Name: #{result.person.try(:name)}"
      puts "Company name: #{result.company.try(:name)}"

      if result.score > 0.5
        puts "Baller"
      end
    else
      puts "Person or company not found"
    end

## Method: `lookup(email, options)`

As well as just passing an email, there are a number of additional options you can send to `Clearbit::LeadScore.lookup`, such as the weights that are used internally. You could also just use the information returned to calculate your own score.

This method uses the [Clearbit Streaming API](https://clearbit.com/docs#streaming) which is especially useful if you're making long-lived requests (i.e. you’re making requests to Clearbit from a messaging queue).

This method returns a hash with **both** person and company data, assuming data for both are available. Otherwise, `result.person` or `result.company` will return `nil`

The default options are:

    {
      twitter_followers_weight:   0.05,
      angellist_followers_weight: 0.05,
      klout_score_weight:         0.05,
      company_twitter_followers_weight: 0.05,
      company_alexa_rank_weight:  0.000005,
      company_google_rank_weight: 0.05,
      company_employees_weight:   0.5,
      company_raised_weight:      0.0000005,
      company_score:              10,
      total_score:                1415
    }

gha_language: Ruby


text:
# Log Laravel Memory usage

[![Build Status](https://github.com/audunru/memory-usage/actions/workflows/validate.yml/badge.svg)](https://github.com/audunru/memory-usage/actions/workflows/validate.yml)
[![Coverage Status](https://coveralls.io/repos/github/audunru/memory-usage/badge.svg?branch=master)](https://coveralls.io/github/audunru/memory-usage?branch=master)
[![StyleCI](https://github.styleci.io/repos/448512424/shield?branch=master)](https://github.styleci.io/repos/448512424)

Log amount of memory used during HTTP requests. The peak memory usage in megabytes will be logged right before the response is returned.

The memory limit is configurable per request path. If you set the limit to 25 MiB for all requests, you will see something like this in your logs:

```
[2022-01-16 10:49:17] local.WARNING: Maximum memory 50.68 MiB used during request for /api/v1/companies/1/products is greater than limit of 25.00 MiB
[2022-01-16 10:49:29] local.WARNING: Maximum memory 50.39 MiB used during request for /api/v1/companies/1 is greater than limit of 25.00 MiB
[2022-01-16 10:49:29] local.WARNING: Maximum memory 60.04 MiB used during request for /api/v1/companies/1/sales is greater than limit of 25.00 MiB
```

Since v0.3.0 you can also log slow responses. If you set the limit to 3 seconds, you you will see something like this in your logs:

```
[2022-01-16 10:49:17] local.WARNING: Response time 5.15 s for /api/v1/companies/1/products is greater than limit of 3.00 s
```

# Installation

## Step 1: Install with Composer

```bash
composer require audunru/memory-usage
```

# Configuration

Publish the configuration file by running:

```php
php artisan vendor:publish --tag=memory-usage-config
```

Please open up the configuration file for further instructions on how to configure logging.

# Development

## Testing

Run tests:

```bash
composer test
```

repository: audunru/memory-usage

gha_language: PHP

gha_license_id: MIT

repo_name: audunru/memory-usage


text:
---
layout: post
title: "Walking meetings are just great!"
subtitle:   "After trying walking meetings"
date: 2013-08-29
author: Lena Barinova
id: 284
categories:
  - Know-how
---

Some time ago I wrote a short [Walking meetings]({{site.baseurl}}{% post_url 2013-08-12-walking-and-talking %}) post about my intention to conduct mid-year evaluation meetings with colleagues outside the office while walking. So here are some insights how it went.

In short: I loved it.

In details: I scheduled these meetings in advance (as always) with some guided questions to gather up the ideas for talk, noticing everyone that we would be outside. Each meeting went by the same schema: we grab a coffee and went to a quiet place - by the river mostly. Everything else as in usual 1:1 - small talk, questions, answers, overview of what happened, plans for future, mutual feedback, etc. In comparison to traditional evaluation meetings, these were more relaxed, easy going, we discussed more things than usual.

It is definitely not for every possible meeting. When you take notes, or show some data, or there are more than 3 attendees - you need something else. But if you are just talking, asking/answering questions - go out! Just remember to check the weather and find not very busy place for a walk.

PS: in total I went 25 km this time!

repository: LenaBarinova/BeBetterLeader

repo_name: LenaBarinova/BeBetterLeader


text:
# Nectria parasitica (Murrill) D. Sacc. SPECIES

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
Malpighia 210 (1898)

#### Original name
Diaporthe parasitica Murrill, 1906

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Sordariomycetes/Diaporthales/Cryphonectriaceae/Cryphonectria/Cryphonectria parasitica/ Syn. Nectria parasitica/README.md

repo_name: mdoering/backbone


text:
# API Review 05/31/2022

## TarReader should not assume same format for all entries in a tar file

**Approved** | [#runtime/69544](https://github.com/dotnet/runtime/issues/69544#issuecomment-1142399023) | [Video](https://www.youtube.com/watch?v=xFjPGD_GFOg&t=0h0m0s)

Looks good as proposed.

```diff

namespace System.Formats.Tar
{
    public partial class TarReader
    {
-       public TarFormat Format { get; }
    }

    public partial class TarEntry
    {
+       public TarFormat Format { get; }
    }
}
```
## Allow multiple Global Extended Attributes entries in Tar archives with PAX format

**Approved** | [#runtime/69935](https://github.com/dotnet/runtime/issues/69935#issuecomment-1142455260) | [Video](https://www.youtube.com/watch?v=xFjPGD_GFOg&t=0h6m59s)

* The new PaxGlobalExtendedAttributesTarEntry looks good as proposed
* Combined with the previous update that moved the TarFormat property from TarReader to TarEntry we made some systematic updates while we were here
  * Instead of the TarWriter doing automatic conversion of any TarEntry into the ctor-provided TarFormat, conversion must be done explicitly by the caller (new conversion constructors), and the TarWriter will just write whatever it's given.
  * TarFormat is now TarEntryFormat since it only applies to entries
  * We kept TarWriter.Format and the constructor parameter, because they control the format for the TarWriter.Write(string, string) method.
    * But we cleaned up the constructors+defaults to take this global extended attributes change into account.

```C#
namespace System.Formats.Tar
{
    public sealed partial class PaxGlobalExtendedAttributesTarEntry : System.Formats.Tar.PosixTarEntry
    {
        public PaxGlobalExtendedAttributesTarEntry(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, string>> globalExtendedAttributes) { }
        public System.Collections.Generic.IReadOnlyDictionary<string, string> GlobalExtendedAttributes { get { throw null; } }
    }

    // Conversion constructors.  They move the DataStream value from other to [new].
    public partial class GnuTarEntry
    {
        public GnuTarEntry(TarEntry other);
    }
    public partial class PaxTarEntry
    {
        public PaxTarEntry(TarEntry other);
    }
    public partial class PosixTarEntry
    {
        public PosixTarEntry(TarEntry other);
    }
    public partial class UstarTarEntry
    {
        public UstarTarEntry(TarEntry other);
    }
    public partial class V7TarEntry
    {
        public V7TarEntry(TarEntry other);
    }
}
```

```diff
namespace System.Formats.Tar
{
    public sealed partial class TarReader : System.IDisposable
    {
-        public System.Collections.Generic.IReadOnlyDictionary<string, string>? GlobalExtendedAttributes { get { throw null; } }
    }

    public sealed partial class TarWriter : System.IDisposable
    {
-        public TarWriter(System.IO.Stream archiveStream, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, string>>? globalExtendedAttributes = null, bool leaveOpen = false) { }
+        public TarWriter(System.IO.Stream archiveStream) {}

-        public TarWriter(Stream archiveStream, TarEntryFormat archiveFormat, bool leaveOpen = false);
+        public TarWriter(Stream archiveStream, TarEntryFormat archiveFormat = TarEntryFormat.Pax, bool leaveOpen = false);
    }

-   public partial enum TarFormat { ... }
+   public partial enum TarEntryFormat { ... }
}
```
## Support for Span<T> and ReadOnlySpan<T> in source-generated marshalling

**Approved** | [#runtime/69281](https://github.com/dotnet/runtime/issues/69281#issuecomment-1142534492) | [Video](https://www.youtube.com/watch?v=xFjPGD_GFOg&t=1h4m11s)

* We removed the NeverNull variants from the approved shape.  The name we were leaning toward was NullAsEmpty instead of NeverNull, but we felt that if the default marshaller matches MemoryMarshal.GetReference instead of Span.GetPinnableReference that we won't need it.
* I added some `readonly` modifiers to where the `ref`s were in the ReadOnlySpan marshaller.  They might be wrong.  Make them be right :smile:.

```C#

namespace System.Runtime.InteropServices.Marshalling
{
    [CustomTypeMarshaller(typeof(ReadOnlySpan<>), CustomTypeMarshallerKind.LinearCollection, Direction = CustomTypeMarshallerDirection.In, Features = CustomTypeMarshallerFeatures.UnmanagedResources | CustomTypeMarshallerFeatures.CallerAllocatedBuffer | CustomTypeMarshallerFeatures.TwoStageMarshalling, BufferSize = 0x200)]
    public unsafe ref struct ReadOnlySpanMarshaller<T>
    {
        public ReadOnlySpanMarshaller(int sizeOfNativeElement);

        public ReadOnlySpanMarshaller(ReadOnlySpan<T> managed, int sizeOfNativeElement);

        public ReadOnlySpanMarshaller(ReadOnlySpan<T> managed, Span<byte> stackSpace, int sizeOfNativeElement);

        public ReadOnlySpan<T> GetManagedValuesSource();
        public Span<byte> GetNativeValuesDestination();
        public ref readonly byte GetPinnableReference();
        public byte* ToNativeValue();
        public void FreeNative();
        public static ref readonly T GetPinnableReference(ReadOnlySpan<T> managed);
    }

    [CustomTypeMarshaller(typeof(Span<>), CustomTypeMarshallerKind.LinearCollection, Features = CustomTypeMarshallerFeatures.UnmanagedResources | CustomTypeMarshallerFeatures.CallerAllocatedBuffer | CustomTypeMarshallerFeatures.TwoStageMarshalling, BufferSize = 0x200)]
    public unsafe ref struct SpanMarshaller<T>
    {
        public SpanMarshaller(int sizeOfNativeElement);

        public SpanMarshaller(Span<T> managed, int sizeOfNativeElement);

        public SpanMarshaller(Span<T> managed, Span<byte> stackSpace, int sizeOfNativeElement);

        public ReadOnlySpan<T> GetManagedValuesSource();
        public Span<T> GetManagedValuesDestination(int length);
        public Span<byte> GetNativeValuesDestination();
        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
        public ref byte GetPinnableReference();
        public byte* ToNativeValue();
        public void FromNativeValue(byte* value);
        public static ref T GetPinnableReference(Span<T> managed);

        public Span<T> ToManaged();

        public void FreeNative();
    }
}
```
## Add AllBitsSet to the IBinaryNumber Interface

**Approved** | [#runtime/69676](https://github.com/dotnet/runtime/issues/69676#issuecomment-1142542210) | [Video](https://www.youtube.com/watch?v=xFjPGD_GFOg&t=1h55m9s)

* Looks good as proposed
* Consider DIMming it as ~Zero

```C#
namespace System.Numerics
{
    public partial interface IBinaryNumber<TSelf>
    {
        static abstract TSelf AllBitsSet { get; }
    }
}
```

repository: dotnet/apireviews

branch_name: refs/heads/main

repo_name: dotnet/apireviews


text:
# MiniBach
Implementation of the MiniBach model described in the book *Deep Learning Techniques for Music Generation*.

----

## About

The `MiniBach` model is very simple (a feedforward network with only one hidden layer) so it can be considered a kind of **Hello World** for symbolic music generation. It is perfect for people just starting with deep learning. For the *not so beginners* on deep learning, maybe the encoding of the music score provides some insight. In any case, I couldn't find an implementation of the model when I saw it on the book, and decided that it would be a nice contribution to the community.

## Code

The implementation is written in a tutorial-like fashion spread out in four notebooks:
- **Part 1**: Taking a collection of `Humdrum **kern` symbolic music files (Bach chorales) and process them into 4-measure chunks of training data
- **Part 2**: Encoding the 4-measure chunks of training data into one-hot-encoded vectors for the neural network, separating the soprano (input) from the three lower voices (output)
- **Part 3**: Training the neural network and predicting the accompaniment for one of the melodies in the training examples
- **Part 4**: Generating the accompaniment for an arbitrary melody

If cloning the repository, clone recursively to get the submodule with the Bach chorales, which are provided by [Craig Sapp](https://github.com/craigsapp/bach-370-chorales):
```
git clone https://github.com/napulen/MiniBach.git --recursive
```

## Requirements

The music processing is done using [music21](http://web.mit.edu/music21/). The network is implemented with `tensorflow`, and `pandas` dataframes are used a few times.

## Source

More details about this and other (more advanced) models can be found in the book:

Briot, Jean-Pierre, Gaëtan Hadjeres, and François Pachet. 2017. “Deep Learning Techniques for Music Generation - A Survey.” CoRR abs/1709.01620. http://arxiv.org/abs/1709.01620.

----
Enjoy!

repository: napulen/MiniBach

repo_name: napulen/MiniBach


text:
# 0x13. Count it!

Write a recursive function that queries the Reddit API, parses the title of all hot articles, and prints a sorted count of given keywords (case-insensitive, delimited by spaces. Javascript should count as javascript, but java should not).

Requirements:

    Prototype: def count_words(subreddit, word_list)
    Note: You may change the prototype, but it must be able to be called with just a subreddit supplied and a list of keywords. AKA you can add a counter or anything else, but the function must work without supplying a starting value in the main.
    If word_list contains the same word (case-insensitive), the final count should be the sum of each duplicate (example below with java)
    Results should be printed in descending order, by the count, and if the count is the same for separate keywords, they should then be sorted alphabetically (ascending, from A to Z). Words with no matches should be skipped and not printed. Words must be printed in lowercase.
    Results are based on the number of times a keyword appears, not titles it appears in. java java java counts as 3 separate occurrences of java.
    To make life easier, java. or java! or java_ should not count as java
    If no posts match or the subreddit is invalid, print a newline.
    NOTE: Invalid subreddits may return a redirect to search results. Ensure that you are NOT following redirects.

Your code will NOT pass if you are using a loop and not recursively calling the function! This /can/ be done with a loop but the point is to use a recursive function. :)

Disclaimer: number presented in this example cannot be accurate now - Reddit is hot articles are always changing.

repository: kyeeh/holbertonschool-interview

repo_name: kyeeh/holbertonschool-interview


text:
# PEB

All you need is to run:

```shell
git clone https://github.com/bound1ess/peb.git
./peb/app create --name my_first_ext
```

That will check your PHP-CPP installation, create a directory for your extension,
copy all needed files and perform some required changes.
Next steps (building and installing your extension) will also be provided.

## Cement dependency

Here is what I did on *Ubuntu 14.04*:

```shell
sudo apt-get install pip3
pip3 install cement
python3
>>> from cement.core import foundation
```

## License

MIT (see the `LICENSE` file).


text:
  Mobile Application Developed in React Native.

  Running on both mobile platforms, Android 🤖 & iOS 🍎.

## ℹ About

⌛ Timer is an app the user can set up its counter time when doing exercises and repetitions.

## 👁 Preview

The app is responsible setting up the counter in minutes or in seconds for the user who may attempt to do and exercise.

Available for Android and iOS.

![ezgif com-gif-maker](https://user-images.githubusercontent.com/51189721/98170184-513c4c80-1ecc-11eb-9164-cd26f8b02695.gif)
![ezgif com-gif-maker (1)](https://user-images.githubusercontent.com/51189721/98170194-53061000-1ecc-11eb-8b6d-7f3c29d41d79.gif)

![ezgif com-gif-maker (2)](https://user-images.githubusercontent.com/51189721/98170198-54373d00-1ecc-11eb-86a2-391cf1ce6314.gif)
![ezgif com-gif-maker (3)](https://user-images.githubusercontent.com/51189721/98170200-55686a00-1ecc-11eb-9785-2eb876956ca4.gif)

## Tech Stack

- [React Native](https://github.com/facebook/react-native)

## Used libraries

Mobile

- [React](https://pt-br.reactjs.org/)

- [React Native](https://reactnative.dev/)

- [React Native Gesture Handler](https://www.npmjs.com/package/react-native-gesture-handler)

- [React Native Reanimated](https://www.npmjs.com/package/react-native-reanimated)

- [React Native Keep Awake](https://www.npmjs.com/package/react-native-keep-awake)

- [React Native Safe Area Context](https://www.npmjs.com/package/react-native-safe-area-context)

- [React Native Screens](https://www.npmjs.com/package/react-native-screens)

- [React Native Sound](https://www.npmjs.com/package/react-native-sound-player)

- [React Native Webview](https://www.npmjs.com/package/react-native-webview)

- [React Navigation](https://reactnavigation.org/)

## 🚀 Getting started

First of all you need to have `node` and `yarn`(or `npm`) installed on your machine.

_If you decide to use npm don't forget to delete yarn.lock in folders_

Then you can clone the repository.

`git clone https:https://github.com/rafapaivadeandrade/Timer`

### Running it locally

- `git clone https://github.com/rafapaivadeandrade/Timer.git`
- `yarn`
- `cd ios/ && pod install`
- `cd .. && react-native link`
- `react-native run-ios` or `react-native run-android`

## 📝 License

This project is under the MIT license. See the [LICENSE]([https://github.com/rafapaivadeandrade/Timer/blob/master/LICENSE.md](https://github.com/rafapaivadeandrade/Timer/blob/master/LICENSE.md)) for more information.

---

repository: rafapaivadeandrade/Timer

repo_name: rafapaivadeandrade/Timer


text:
# P2P Port Filter

## Installation

Basic install:
```sh
sudo apt install jq
git clone https://github.com/geopsllc/core-filter
cd core-filter
bash filter.sh # To Enable The Filter
bash restore.sh # To Restore The Allow From Any
```

- The list of IPs is taken from the official ARK API.
- Requires UFW to be active/enabled. Works on Ubuntu 16.04 and 18.04.
- The peer IP for the ARK API node we got the info from will not be added to the allowed list.
- You should run this script often to keep the current list of nodes updated or use the following point.
- If you want to cron this script you should use filter-cron and add it to the system cron. Hourly example:
```sh
cd core-filter
sudo cp filter-cron /etc/cron.hourly/
```

repository: geopsllc/core-filter

repo_name: geopsllc/core-filter


text:
# PHP - cURL
PHP Wrapper and tools for cURL

---

The project is currently in beta, changes and compability breaks are to be expected

---

## Installation
The recommended way to install is through [Composer](https://getcomposer.org/).
```JSON
{
    "require": {
        "xicrow/php-curl": "dev-master"
    }
}
```

## License
Copyright © 2018 Jan Ebsen
Licensed under the MIT license.


text:
[![](https://travis-ci.org/tuanpmt/espmqtt.svg?branch=master)](https://travis-ci.org/tuanpmt/espmqtt)
[![](http://hits.dwyl.io/tuanpmt/espmqtt.svg)](http://hits.dwyl.io/tuanpmt/espmqtt)
[![Twitter Follow](https://img.shields.io/twitter/follow/tuanpmt.svg?style=social&label=Follow)](https://twitter.com/tuanpmt)
![GitHub contributors](https://img.shields.io/github/contributors/tuanpmt/espmqtt.svg)

# ESP32 MQTT Library

## Features

- Based on: https://github.com/tuanpmt/esp_mqtt
- Support MQTT over TCP, SSL with mbedtls, MQTT over Websocket, MQTT over Websocket Secure
- Easy to setup with URI
- Multiple instances (Multiple clients in one application)
- Support subscribing, publishing, authentication, will messages, keep alive pings and all 3 QoS levels (it should be a fully functional client).

## How to use

Clone this component to [ESP-IDF](https://github.com/espressif/esp-idf) project (as submodule):
```
git submodule add https://github.com/tuanpmt/espmqtt.git components/espmqtt
```

Or run a sample (make sure you have installed the [toolchain](http://esp-idf.readthedocs.io/en/latest/get-started/index.html#setup-toolchain)):

```
git clone https://github.com/tuanpmt/espmqtt.git
cd espmqtt/examples/mqtt_tcp
make menuconfig
make flash monitor
```

## Documentation
### URI

- Curently support `mqtt`, `mqtts`, `ws`, `wss` schemes
- MQTT over TCP samples:
    + `mqtt://iot.eclipse.org`: MQTT over TCP, default port 1883:
    + `mqtt://iot.eclipse.org:1884` MQTT over TCP, port 1884:
    + `mqtt://username:password@iot.eclipse.org:1884` MQTT over TCP, port 1884, with username and password
- MQTT over SSL samples:
    + `mqtts://iot.eclipse.org`: MQTT over SSL, port 8883
    + `mqtts://iot.eclipse.org:8884`: MQTT over SSL, port 8884
- MQTT over Websocket samples:
    + `ws://iot.eclipse.org:80/ws`
- MQTT over Websocket Secure samples:
    + `wss://iot.eclipse.org:443/ws`
- Minimal configurations:

```c
const esp_mqtt_client_config_t mqtt_cfg = {
    .uri = "mqtt://iot.eclipse.org",
    .event_handle = mqtt_event_handler,
    // .user_context = (void *)your_context
};
```

- If there are any options related to the URI in `esp_mqtt_client_config_t`, the option defined by the URI will be overridden. Sample:

```c
const esp_mqtt_client_config_t mqtt_cfg = {
    .uri = "mqtt://iot.eclipse.org:1234",
    .event_handle = mqtt_event_handler,
    .port = 4567,
};
//MQTT client will connect to iot.eclipse.org using port 4567
```

### SSL

- Get Certification from server, example: `iot.eclipse.org` `openssl s_client -showcerts -connect iot.eclipse.org:8883 </dev/null 2>/dev/null|openssl x509 -outform PEM >iot_eclipse_org.pem`
- Check the sample application: `examples/mqtt_ssl`
- Configuration:

```cpp
const esp_mqtt_client_config_t mqtt_cfg = {
    .uri = "mqtts://iot.eclipse.org:8883",
    .event_handle = mqtt_event_handler,
    .cert_pem = (const char *)iot_eclipse_org_pem_start,
};
```

### More options for `esp_mqtt_client_config_t`

-  `event_handle` for MQTT events
-  `host`: MQTT server domain (ipv4 as string)
-  `port`: MQTT server port
-  `client_id`: default client id is `ESP32_%CHIPID%`
-  `username`: MQTT username
-  `password`: MQTT password
-  `lwt_topic, lwt_msg, lwt_qos, lwt_retain, lwt_msg_len`: are mqtt lwt options, default NULL
-  `disable_clean_session`: mqtt clean session, default clean_session is true
-  `keepalive`: (value in seconds) mqtt keepalive, default is 120 seconds
-  `disable_auto_reconnect`: this mqtt client will reconnect to server (when errors/disconnect). Set `disable_auto_reconnect=true` to disable
-  `user_context` pass user context to this option, then can receive that context in `event->user_context`
-  `task_prio, task_stack` for MQTT task, default priority is 5, and task_stack = 6144 bytes (or default task stack can be set via `make menucofig`).
-  `buffer_size` for MQTT send/receive buffer, default is 1024
-  `cert_pem` pointer to CERT file for server verify (with SSL), default is NULL, not required to verify the server
-  `client_cert_pem` pointer to CERT file for SSL mutual authentication, default is NULL, not required if mutual authentication is not needed. If it is not NULL, also `client_key_pem` has to be provided.
-  `client_key_pem` pointer to PEM private key file for SSL mutual authentication, default is NULL, not required if mutual authentication is not needed. If it is not NULL, also `client_cert_pem` has to be provided.
-  `transport`: override URI transport
    +  `MQTT_TRANSPORT_OVER_TCP`: MQTT over TCP, using scheme: `mqtt`
    +  `MQTT_TRANSPORT_OVER_SSL`: MQTT over SSL, using scheme: `mqtts`
    +  `MQTT_TRANSPORT_OVER_WS`: MQTT over Websocket, using scheme: `ws`
    +  `MQTT_TRANSPORT_OVER_WSS`: MQTT over Websocket Secure, using scheme: `wss`

### Change settings in `menuconfig`

```
make menuconfig
-> Component config -> ESPMQTT Configuration
```

## Example

Check `examples/mqtt_tcp` and `examples/mqtt_ssl` project. In Short:

```cpp

static esp_err_t mqtt_event_handler(esp_mqtt_event_handle_t event)
{
    esp_mqtt_client_handle_t client = event->client;
    int msg_id;
    // your_context_t *context = event->context;
    switch (event->event_id) {
        case MQTT_EVENT_CONNECTED:
            ESPMQTT_LOGI(TAG, "MQTT_EVENT_CONNECTED");
            msg_id = esp_mqtt_client_subscribe(client, "/topic/qos0", 0);
            ESPMQTT_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);

            msg_id = esp_mqtt_client_subscribe(client, "/topic/qos1", 1);
            ESPMQTT_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);

            msg_id = esp_mqtt_client_unsubscribe(client, "/topic/qos1");
            ESPMQTT_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
            break;
        case MQTT_EVENT_DISCONNECTED:
            ESPMQTT_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
            break;

        case MQTT_EVENT_SUBSCRIBED:
            ESPMQTT_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
            msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0);
            ESPMQTT_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
            break;
        case MQTT_EVENT_UNSUBSCRIBED:
            ESPMQTT_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
            break;
        case MQTT_EVENT_PUBLISHED:
            ESPMQTT_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
            break;
        case MQTT_EVENT_DATA:
            ESPMQTT_LOGI(TAG, "MQTT_EVENT_DATA");
            printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
            printf("DATA=%.*s\r\n", event->data_len, event->data);
            break;
        case MQTT_EVENT_ERROR:
            ESPMQTT_LOGI(TAG, "MQTT_EVENT_ERROR");
            break;
    }
    return ESP_OK;
}
const esp_mqtt_client_config_t mqtt_cfg = {
    .uri = "mqtt://iot.eclipse.org",
    .event_handle = mqtt_event_handler,
    // .user_context = (void *)your_context
};

esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
esp_mqtt_client_start(client);
```

## License
- MQTT Package - [Stephen Robinson - contiki-mqtt](https://github.com/esar/contiki-mqtt)
- Others [@tuanpmt](https://twitter.com/tuanpmt)
Apache License

repository: LaurentLouf/esp-mqtt

repo_name: LaurentLouf/esp-mqtt


text:
---
layout: post
title: "Deep Sparse Subspace Clustering"
date: 2017-09-25 08:43:04
categories: arXiv_CV
tags: arXiv_CV Sparse Knowledge Deep_Learning
author: Xi Peng, Jiashi Feng, Shijie Xiao, Jiwen Lu, Zhang Yi, Shuicheng Yan
mathjax: true
---

* content
{:toc}

##### Abstract
In this paper, we present a deep extension of Sparse Subspace Clustering, termed Deep Sparse Subspace Clustering (DSSC). Regularized by the unit sphere distribution assumption for the learned deep features, DSSC can infer a new data affinity matrix by simultaneously satisfying the sparsity principle of SSC and the nonlinearity given by neural networks. One of the appealing advantages brought by DSSC is: when original real-world data do not meet the class-specific linear subspace distribution assumption, DSSC can employ neural networks to make the assumption valid with its hierarchical nonlinear transformations. To the best of our knowledge, this is among the first deep learning based subspace clustering methods. Extensive experiments are conducted on four real-world datasets to show the proposed DSSC is significantly superior to 12 existing methods for subspace clustering.

##### Abstract (translated by Google)
在本文中，我们提出了稀疏子空间聚类的深度扩展，称为深度稀疏子空间聚类（DSSC）。通过对学习深度特征的单位球面分布假设进行调整，DSSC可以同时满足SSC的稀疏性原理和神经网络给出的非线性性，推导出新的数据亲和性矩阵。 DSSC带来的一个吸引人的优势是：当原始现实世界的数据不符合类特定的线性子空间分布假设时，DSSC可以利用神经网络使其分层非线性变换成为有效的假设。就我们所知，这是第一个基于深度学习的子空间聚类方法。对四个真实世界的数据集进行了广泛的实验，以显示所提出的DSSC比子空间聚类的12个现有方法明显优越。

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

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


text:
# ofxOpenCvDnnObjectDetection

## Description
ofxOpenCvDnnObjectDetection is an addon for openframeworks.

OpenCV v.3.3.1 or upper includes dnn module ( https://docs.opencv.org/3.4.1/da/d9d/tutorial_dnn_yolo.html ) in their own package. Therefore I designed ofxOpenCvDnnObjectDetection with OpenCV v.3.3.1 or upper version.

I created this addon for beginers or learner who are going to try object detection with Yolo, SSD and R-CNN on OF.

## Usage
See Examples

### single_image
![single_image screenshot](/screenshot.png)
Detection example for single image.

### camera
Realtime Detection example for webcam video.

### annotation
![annotation screenshot](/screenshot_annotation.png)
Simple annotation example to export a yolo format.

## Install
### 1. Install OpenCV version.3 by brew.

    $ brew install opencv@3

### 2. confirm your opencv version
Based on OpenCV@3(version.3) version, Please re-write ofxOpenCvDnnObjectDetection/addon_config.mk file. End of the file, there are some description about opencv path for your system. Please re-write the version according to your OpenCV@3 version. Current (2019/3/1) is 3.4.5, If you find other version on your directory tree, /usr/local/Cellar/opencv@3 , please do not forget fill in the correct version on the addon_config.mk file. You can get your current opencv version by typing below command.

    $ ls /usr/local/Cellar/opencv@3

### 3. Download cfg and weights file
I put a download shell script on the ofxOpenCvDnnObjectDetection directory. it will download Yolov2 file(cfg and weights) to each examples directories. You can find download ofxYolov2 weights and cfg files on each example directories.

    $ cd ofxOpenCvDnnObjectDetection
    $ sh getWeights.sh

### 4. Update each examples by project generator, then run.
 Example/camera, single_image or annotation by project generator and add only ofxOpenDvDnnObjectDetection as an addon. Then update it. _Attention Please do not include OpenCV addon in OF.

## Compatibility
- only macOS ( tested on Mojave)
- of version: 0.10.1

## Licence
[MIT](https://opensource.org/licenses/MIT)

## Author
[TetsuakiBaba](https://github.com/TetsuakiBaba)

## Reference
1. Model Zoo on OpenCV DNN Module README page: https://github.com/opencv/opencv/blob/master/samples/dnn/README.md
2. How to implement OpenCV Yolo on Openframeworks: https://qiita.com/buchayaty/items/4020100f531c07418f38

repository: AnasGhrab/ofxOpenCvDnnObjectDetection

repo_name: AnasGhrab/ofxOpenCvDnnObjectDetection


text:
---
layout: post
title: "Using Apache Flume-NG to move binaries around"
date: 2014-03-26 16:32:19 -0400
comments: true
categories: [linux, hadoop, flume-ng]
---

Need to move small binary files from one server to the other? Flume-NG to the
rescue! It supports complex topologies and is quite fast about it.

1. Install flume-ng on your server (Cloudera's CDH4 packages are nice).

2. Set up a source and a destination directories and a configuration
   file, in our case flume-ng-agent.conf.

{% gist salekseev/310c94d7f12d40cd97d9 %}

3. Launch a flume agent

<code>
flume-ng agent --conf-file flume-ng-agent.conf --name a1 -Dflume.root.logger=INFO,console
</code>

4. Drop some binaries into the ~/source folder and watch them appear in
   the ~/dest folder. Originals are by default renamed with a .COMPLETE
suffix but could also be removed.

The only downside is the the default serializer for file_roll sink does
not preserve the original filename.

Always a good idea to look at the docs for more info -
[http://archive-primary.cloudera.com/cdh4/cdh/4/flume-ng/](http://archive-primary.cloudera.com/cdh4/cdh/4/flume-ng/).


text:
---
title: "Not easy"
date: "2018-06-11"
author: Wolfr_
---

We've been thinking hard about who Bedrock is for.

The current answer is: it's for designers who want to reach the next level.

Bedrock is extremely powerful, but it is not easy to use.

I actually had "easy to use" on the website for a while, as a marketing message.

I thought about it. For months I've thought about how to make things easier.

With the upcoming 1.10 release it will be much easier to get into than before.

The thing is that learning to work with Bedrock is not easy - but learning to work with Bedrock is worthwhile.

If a designer learns to work with Bedrock they will be able to communicate their designs at scale, with a level of realism that design apps can only dream of.

But to do so you will need to learn about quite a few concepts.

And to work efficiently you basically need to know how to code HTML and CSS, and then be able to work with things like SCSS and Pug as well.

You need to way around a terminal, and you need to know about version control.

For a long time I thought about trying to simplify Bedrock, to try to make it easier to use.

But the problem is that I can't make the reality of building complex web apps easier.

And I also don't want to dumb down Bedrock with choices to make it more dummy-proof leading to a development environment I don't want to use myself.

So, Bedrock is not easy.

It's definitely not for the designer who doesn't want to code.

But once you get past the hurdles, you will be rewarded with a powerful tool.


text:
# m1-catalog-configurable
Show all options for out of stock child products for configurable product

Defaut Magento 1 behaviour is to check at least 1 child product is saleable then it will show all child product options.
But you want to show all out of stock options to make existing and new customers.

If you install this extension you will see all out of stock options visible on frontend.

#### Upcoming feature:
Show cross line over swatches on page load on product view and product listing page


text:
+++
title = "Lectotypification of twenty names of Chinese taxa in Angiospermae [In Chinese]"
date = 2008-01-01T00:00:00
draft = false

# Authors. Comma separated list, e.g. `["Bob Smith", "David Jones"]`.
authors = ["Qi Lin", "Shu-Qing Bei", "Hong-Li Li", "Zi-Yu Cao", "Qian Sun", "**_Miao Sun_**", "Zhi-Rong Yang"]

# Publication type.
# Legend:
# 0 = Uncategorized
# 1 = Conference paper
# 2 = Journal article
# 3 = Manuscript
# 4 = Report
# 5 = Book
# 6 = Book section
publication_types = ["2"]

# Publication name and optional abbreviated version.
publication = "In *Bulletin of Botanical Research*"
publication_short = "In **"

# Abstract and optional shortened version.
abstract = "Based on examinations of type specimens housed at PE, lectotypes for twenty names of Chinese taxa in Angiospermae are here designated under Article 8.1, 9.9, 9.10 and 37.2, Recommendation 9A.2 and 9A.3 of the International Code of Botanical Nomenclature (Vienna Code), because the types were respectively indicated by reference to a gathering that consists of more than one specimen, or more than one gatherings were simultaneously designated as types, or more than one gatherings were simultaneously designated, without indicating the type in the protologue."
abstract_short = ""

# Is this a selected publication? (true/false)
selected = false

# Projects (optional).
#   Associate this publication with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["deep-learning"]` references
#   `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects = ["taxonomy"]

# Slides (optional).
#   Associate this publication with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references
#   `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
# slides = "example-slides"

# Tags (optional).
#   Set `tags = []` for no tags, or use the form `tags = ["A Tag", "Another Tag"]` for one or more tags.
tags = ["Plant Specimen", "Herbarium Work", "Nomenclature", "Vienna Code"]

# Links (optional).
url_pdf = "http://bbr.nefu.edu.cn/EN/10.7525/j.issn.1673-5102.2008.05.007#"
# url_preprint = ""
# url_code = ""
# url_dataset = ""
# url_project = ""
# url_slides = ""
# url_video = ""
# url_poster = ""
url_source = "http://bbr.nefu.edu.cn/EN/abstract/abstract753.shtml"

# Custom links (optional).
#   Uncomment line below to enable. For multiple links, use the form `[{...}, {...}, {...}]`.
# url_custom = [{name = "Custom Link", url = "http://example.org"}]

# Digital Object Identifier (DOI)
doi = "10.7525/j.issn.1673-5102.2008.05.007"

# Does this page contain LaTeX math? (true/false)
math = false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
[image]
  # Caption (optional)
  caption = ""

  # Focal point (optional)
  # Options: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight
  focal_point = "Smart"
+++

repository: Cactusolo/CactusOasis

repo_name: Cactusolo/CactusOasis


text:
+++
Talk_date = ""
Talk_start_time = ""
Talk_end_time = ""
Title = "The delivery pipeline @ Banco BPI"
Type = "talk"
Speakers = ["hugo-amorim"]
+++

### Context

This talk reports a real-world experience regarding a DevOps adoption at BancoBPI. BancoBPI is one of the top five banks in Portugal. Our IT division is bigger than most SME IT companies in Portugal are. We manage a vast and heterogeneous IT ecosystem. More than 80 development teams are responsible for developing hundreds of application components and thousands of services. These application components and services are spread across different platforms, that span from the decades-old Mainframe platform, where we still have some applications from the ’80s, to the cutting edge mobile platforms for iOS and Android apps. On top of all these platforms, we have dozens of different technologies. Applications components and services change at a very frequent pace to adapt to a quickly changing business in a heavily regulated market with strict audit requirements.

### Challenge

How to handle the integration challenges of an IT ecosystem with thousands of services and where a significant percentage of business requests crosscut multiple systems? How to orchestrate all these changes from development to production, in compliance with regulatory demands, including strict traceability and audit requirements? How to assure the IT systems robustness and the information security expected from a bank?

### The Journey

At the begging of this journey, we were faced with a set of issues that were split into two main vectors: 1. Diversity: different tools, different repositories, and different processes, which turned integration and traceability into challenging and time-consuming tasks; 2. Automation: or lack of it, since a significant part of the procedures on the application lifecycle were manual-based tasks which, besides being error-prone, limited the ability to get faster and accurate feedback.

##### Culture

We started by merging all SCM tools in a single SCM platform. Today, all teams use the same terminology, the same interface, the same way of managing changes and deliver them, the same processes regardless of the technology or platform. This merge gave us the necessary process standardization and the ability to orchestrate the delivery process with a single workflow that guides each change from DEV to PRD. The single SCM platform is now the starting point of all delivery processes, which simplifies traceability and shortens the feedback loop for delivery actions. Having a similar way of managing and deliver changes also allowed us to consolidate continuous integration practices, which in turn helped to integrate cross-platform changes by guaranteeing the necessary consistency between environments and technologies.

##### Automation

We also did a lot of work on Automation towards zero manual-based delivery processes. We added the support to several types of artifacts that were manually delivered (database as code, application configurations, infrastructure configurations, deploy configurations). Currently, the delivery of almost all types of artifacts is fully automated for all technologies and environments. This automation helped to eliminate failures due to human error, to reduce the feedback loop for all changes and to obtain the necessary consistency between multiple deploys across all environments in order to give development teams the confidence to repeat the delivery process as often as necessary.

##### Lean

An important role regarding the success of this initiative is played by development teams. The Scrum methodology adopted by all development teams was another important driver for this transformation. A methodology that relies on shorter feedback-back loops and continuous improvement is the perfect match for a DevOps adoption.

### Benefits

* Consistent deploys on all environments
* Improved logging and traceability
* Real-time feedback
* No surprises

### Future steps

* Continuous Delivery
*Application Catalog
*Monitoring
*KPIs

repository: gsreynolds/devopsdays-web

gha_license_id: NOASSERTION

repo_name: gsreynolds/devopsdays-web


text:
# SignPackage

To notarize Java apps on macOS it is necessary to sign all jar and dylib files in the .app package with the same signature.
dylib files can even exist inside jar files and have to be signed inside the jar file, too. This program here performs the
codesign process. You can use it e.g. like this:

```
java -jar SignPackage.jar -d appimageoutput -t -r -k "Developer ID Application: John Public (XXXXXXXXXX)" -e "src/main/deploy/package/macosx/MyApp.entitlements"
```

The parameters are:
```
-d The directory that contains the files that have to be codesigned.
-t Set secure timestamp using the codesign timestamp parameter
-r Harden using the codesign runtime parameter
-k Key name
-e Entitlements file
-x Excludes files from being signed. Can be used multiple times to specify multiple files. You have to specify the path including directories.
```

It is explained further here: https://blog.dgunia.de/2020/02/12/signed-macos-programs-with-java-14/

To build the SignPackage.jar file just run build.sh.

gha_language: Kotlin


text:
# fahclient_handler

[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)]

Folding@Home wrapper to automatically start/stop fahclient service (using systemd) by monitoring system métrique (load and temperature).

Folding@Home currently doesn't fit well with systemd (https://github.com/FoldingAtHome/fah-issues/issues/1396), you may want to add the service file in this repo to /etc/systemd/system/fahclient.service location. Then run a systemctl daemon-reload to apply changes.

## How to use

fahclient_handler.py is a daemon which can be run as a service.

2 parameters can be use:
* Temperature in celsius degre
* Load which is a percentage of total load available. Let's say you have 8 thread, 0.5 mean that limit be reach on a 15 min average load of 4.

When the daemon start or stop fahclient, it will wait 20 minutes before starting/stoping back fahclient (preventing quick start and stop of fahclient if your system metric are close to the limit you set).

Example:

python3 fahclient_handler.py --load 0.6 -temp 95


text:
Socialoud
=========
With this gem you can create your custom social network overview.
See the default example app [here](http://github.com/endel/socialoud-default).

Recomendations
-------------
This gem requests the API of services almost every function call, so it is recomended to you cache the result generated by Socialoud.

Avaible services
----------------
- Gravatar
- Github
- LinkedIn
- Twitter
- Facebook (weak)

License
-------
Socialoud is released under the MIT license.

repository: robot-test/socialoud

repo_name: robot-test/socialoud


text:
# filipino-badwords-list

A highly consumable list of bad (profanity) filipino words.

Inspired by [badwords-list](https://github.com/web-mech/badwords-list)

This data has been exposed as an object that contains

- an array
- an object
- a regular expression

depending on what is required for your purposes.

## Install

```
npm i filino-badwords-list
```

## Usage

```js
const list = require("filipino-badwords-list"),
  array = list.array,
  object = list.object,
  regex = list.regex;
```

## Testing

#### Requires

- Jest

```
npm test
```

## Contributing

If you know filipino bad word(s), please contribute to grow our list of filipino bad words and make the web a better place.

[Please follow these steps to contribute](https://github.com/jromest/filipino-badwords-list/blob/master/CONTRIBUTING.md)

## License

MIT

repository: karviesays/filipino-badwords-list

repo_name: karviesays/filipino-badwords-list


text:
# battlesnake
[![Build Status](https://travis-ci.org/Flipez/battlesnake.svg?branch=master)](https://travis-ci.org/Flipez/battlesnake)

This is my first crystal project.

Trying to create a cool battlesnake for battlesnake.io

## Contributing

1. Fork it ( https://github.com/Flipez/battlesnake/fork )
2. Create your feature branch (git checkout -b my-new-feature)
3. Commit your changes (git commit -am 'Add some feature')
4. Push to the branch (git push origin my-new-feature)
5. Create a new Pull Request

## Contributors

- [Flipez](https://github.com/Flipez) Robert Müller - creator, maintainer

repository: ICTWVSS/battlesnake

repo_name: ICTWVSS/battlesnake


text:
# js-on-lua
JavaScript written in LUA.

This repository contains simplified Javascript implementation written in JavaScript grammar.

It is intended to be a source of truth for getting instant and deep understanding what JS is from its roots.

## See also

- [https://www.ecma-international.org/ecma-262/8.0/](ECMA standard)

repository: jfparadis/js-on-lua

repo_name: jfparadis/js-on-lua


text:
# _flyctl volumes_

Volume management commands

### About

Commands for managing Fly Volumes associated with an application.

### Usage
```
flyctl volumes [command] [flags]
```

### Available Commands
* [create](/docs/flyctl/volumes-create/)	 - Create new volume for app
* [delete](/docs/flyctl/volumes-delete/)	 - Delete a volume from the app
* [list](/docs/flyctl/volumes-list/)	 - List the volumes for app
* [show](/docs/flyctl/volumes-show/)	 - Show details of an app's volume

### Options

```
  -a, --app string      App name to operate on
  -c, --config string   Path to an app config file or directory containing one (default "./fly.toml")
  -h, --help            help for volumes
```

### Global Options

```
  -t, --access-token string   Fly API Access Token
  -j, --json                  json output
  -v, --verbose               verbose output
```

### See Also

* [flyctl](/docs/flyctl/help/)	 - The Fly CLI

repository: SpaYco/docs

repo_name: SpaYco/docs


text:
# DynamicRecordCreator Class

Namespace: [CsvHelper.Expressions](/api/CsvHelper.Expressions)

Creates dynamic records.

```cs
public class DynamicRecordCreator : RecordCreator
```

Inheritance Object -> RecordCreator -> DynamicRecordCreator

## Constructors
  |
- | -
DynamicRecordCreator(CsvReader) | Initializes a new instance.

repository: mattosaurus/CsvHelper

repo_name: mattosaurus/CsvHelper


text:
## Description

This test validates the use of parameter resources in validate.cel subrule.

This test creates the following:
1. A namespace `test-params`
2. A namespaced custom resource definition `ReplicaLimit`
3. A policy that checks the statefulset replicas using the parameter resource. The `validate.cel.paramRef.namespace` is unset so it is expected to retrieve the parameter resource from the statefulset's namespace
4. Two statefulsets.

## Expected Behavior

The statefulset `statefulset-fail` is blocked, and the statefulset `statefulset-pass` is created.

repository: nirmata/kyverno

gha_language: Go

repo_name: nirmata/kyverno


text:
# Kermit the log

Kermit is a Kotlin Multiplatform logging utility with composable log outputs. The library provides prebuilt loggers for
outputting to platform logging tools such as Logcat and NSLog.

> Check out [KaMP Kit](https://github.com/touchlab/KaMPKit) to get started developing for Kotlin Multiplatform

## Version Note - September 2021

Kermit is getting some updates. Docs and samples are also in the refresh process and may be a little outdated.

## Most Users Read This

If you don't care about the philosophy of logging, custom configurations, and especially if you're writing for native mobile (KMM),
then you should just do the following.

### Add Dependency

The Kermit dependency should be added to your `commonMain` source set in your Kotlin Multiplatform module.

```kotlin
commonMain {
    dependencies {
        implementation(kotlin("stdlib-common"))
        implementation("co.touchlab:kermit:x.y.z") //Add latest version
    }
}
```

### Basic Config

Kermit will log to `println()` by default. To get platform-specific loggers (which you probably want), do this
somewhere on init:

```kotlin
Logger.setLogWriters(platformLogWriter())
```

### Log

```kotlin
Logger.i { "Hello World" }
```

The rest of the docs explain more detailed options, but at this point you should be able to log from common
code.

## Basic Concepts

The basic components you'll need to be aware of are `Logger`, `LogWriter`, and `Severity`.

### Logger

The `Logger` takes log calls from your code and dispatches them to `LogWriter` instances. There are different methods
on `Logger` corresponding to different log `Severity` levels. In order of least to most severe: v(), d(), i(), w(), e(),
and a().

You configure the `Logger`, then call log methods on it. That's the basic interaction with Kermit.

### LogWriter

A `LogWriter` actually sends log messages to different log outputs. You add `LogWriter` instances to a `Logger`.

Kermit includes a `CommonWriter` and various platform-specific `LogWriter` instances. Through other modules, Kermit
also allows logging crash info to Crashlytics and Bugsnag.

For more info on included `LogWriter` types, and to create your own, see [LOG_WRITER](docs/LOG_WRITER.md)

### Severity

Severity levels follow common logging library patterns and should be generally familiar. You can control what will
and won't get logged based on severity. So, say you only want to log `Warn` and up, you can tell the logger. We'll
cover that more in [Configuration](#Configuration)

## Usage

You call logging methods on a `Logger` instance. There are methods for each severity level. Each call takes an optional
`Throwable` instance, and a lambda which returns a string. The Logger will only evaluate
the lambda if there is an enabled log writer that will write.

In its most basic form, logging looks like this:

```kotlin
Logger.i { "Hello World" }
```

If you are not familiar with the curly bracket syntax, that is a [trailing lambda with special syntax](https://kotlinlang.org/docs/lambdas.html#passing-trailing-lambdas).
Again, that will not be evaluated if no log writer needs it. String creation can be relatively costly if you don't need it,
so Kermit will avoid creating the string if it is not being logged.

The call above is on the global `Logger` instance. You can make all of your logging on the global instance, but for custom
tags, and potentially for performance reasons, you can use local instances as well.

### Local

Local usage is basically the same in concept. You simply call the same method on a local instance.

```kotlin
val logger = Logger.withTag("MyLogger")
logger.i { "Hello World" }
```

You can supply a different tag for the logger through local instances. This is more
meaningful in an Android context. However, there are also potential performance related reasons for local loggers.
See [PERFORMANCE](PERFORMANCE.md) for more info.

## Configuration

You can configure two parameters for LoggerConfig: `LogWriter` instances and minimum severity.

### LogWriter Instances

By default, only the `CommonWriter` is enabled. You can swap other `LogWriter` instances. The most common scenario
is platform-default. There is a convenience function for that.

```kotlin
Logger.setLogWriters(platformLogWriter())
```

For more fine-grained control, you can supply log writers individually. See [LOG_WRITER](docs/LOG_WRITER.md).

### Default Tag

The default tag is the tag used while logging if you have no changed a Logger-specific tag. By default, it is "Kermit".
You can change the default global tag with:

```kotlin
Logger.setDefaultTag("MyTag")
```

### Minimum Severity

To avoid logging lower level statements, you can set a minimum severity. This will prevent evaluating log
message lambdas for those severities. To configure the global minimum severity, add:

```kotlin
Logger.setMinSeverity(Severity.Warn)
```

You may only want to turn this on in production, or by some other flag. Be careful, as it'll be easy
to turn this on and forget, then not see debug log statements. For that reason, it is probably best left
alone unless in a production situation.

### Local Configuration

The configuration above is on the global instance. For a number of reason, you may want a local `Logger` instead.
We provide a static config instance for situations where you con't need mutable config or global logging.

```kotlin
val logger = Logger(StaticConfig(minSeverity = Severity.Warn, loggerList = listOf(CommonWriter())))
logger.i { "Hello Local!" }
```

See [PERFORMANCE](docs/PERFORMANCE.md) for more info.

## Tags

Each `Logger` instance has a tag associated with it, which is initialized by the default tag if none is provided. Tags
help categorize log statements. This feature is largely derived from Android, but can be useful in other contexts.

Tags are passed to `LogWriter` implementations which can decide how to use them (or ignore them). For example, `LogcatWriter` on Android
passes it along to Logcat's tag field.

You can override the global default tag [(see Default Tag)](#Default-Tag).

To have a tag other than default, create a new `Logger` instance with:

```kotlin
val newTagLogger = logger.withTag("newTag")
```

## iOS

Generally speaking, Kermit's SDK was designed to be called from Kotlin, but you can initialize and call logging from any
platform that has interop with Kotlin. For iOS and Swift-specific considerations, see [IOS_CONSIDERATIONS](docs/IOS_CONSIDERATIONS.md)

## Sample

Kermit comes with a Sample Multiplatform project which gives a brief example of how it can be used in both Android and iOS.
The example demonstrates logs being called from within common code as well as from each platform.

### OSLogLogger

The iOS sample also includes a custom logger for outputting using `os_log`. `os_log` is not currently available in
Kotlin/Native and consequently could not be included as a prebuilt logger in the library, but does serve as a good
demonstration of custom logger implementation.

## Primary Maintainer

[Michael Friend](https://github.com/mrf7/)

![Image of Michael](https://avatars.githubusercontent.com/u/16885048?s=140&v=4)

repository: faogustavo/Kermit

repo_name: faogustavo/Kermit


text:
---
layout: page
title: About
permalink: /about/
---
Thanks for checking in! I'm Ben, a Korean-American at the University of Chicago studying Computer Science and East Asian Language and Civilizations. I plan on making this website a place for me to write on thoughts and arguments that are flowing in the head. Every idea and arguement I make is not with the intention of inciting anger, but rather as a test of logic and explanation. I think this will help me create better discourse between myself and my friends.

### More Information

I used to be invested in professional League of Legends, with my friend, Leon, pushing me to watch The League of Legends Pro League (LPL), or the top level of professional Chinese League of Legends. Since then I've read up much more on how each other major region in professional League of Legends, meta shifts, and large macro trends in the game. Since then, I've been interested in working more with professional League of Legends data, because Leon recommended I get into League of Legends more seriously. I've competed at my school for intramurals as well as inter-collegiate League of Legends.

#### May 2023

I've been more interested in philosophy and understanding the world around me. Many of the thoughts I put out in my blog are not firm beliefs but thoughts that are permeating my mind. These are often in context to current events, geopolitics, potential future circumstances, and my own life.

Recent books I've read that have shaped some of my recent thinking include *Beyond Good and Evil* by Friedrich Nietzsche, *The Road to Wigan Pier* by George Orwell, and, currently, *Groundwork of the Metaphysics of Morals* by Immanuel Kant. I plan to read *Daybreak* by Nietzsche, *Hard Times* by Charles Dickens, and *Debating Darwin* by  Michael Ruse and Robert J. Richards.

One thing I'd urge people to do more is, while holding to one's ideals, to take an argument not as an attack on self, but rather as a chance to frame it against your own ideals to reveal flaws with that argument or to bolster your own ideals. The goal of an argument should never be to "win" the argument.

### Contact me

[bencheong99<EMAIL_ADDRESS>
Discord: sockratees#1262


text:
# react-example
React application built with [Fastpack](https://github.com/fastpack/fastpack)

![Fastpack in action](/Screenshot.gif?raw=true)

The small React application including [styled-components](https://www.styled-components.com/), [Redux](https://redux.js.org/) and [redux-saga](https://github.com/redux-saga/redux-saga).

To run it locally, first install [watchman](https://facebook.github.io/watchman/).

You can use [Homebrew](https://brew.sh) on MacOS as following:

```bash
brew update
brew install watchman
```

On Ubuntu you can build it from sources as described in [this post](https://medium.com/@vonchristian/how-to-setup-watchman-on-ubuntu-16-04-53196cc0227c).

Finally, run:

```bash
yarn
yarn start
```

The screenshot above is from the average MacBook Pro 2015.

Have fun!


text:
#GsDevKit Server and Client Installation

A complete GsDevKit installation includes both a server and a client, which can be on the same or on different nodes.  These instructions provide information on installing both on a single node. This is part of the [instructions for installing on a single desktop machine][1]; refer to these instructions for the OS configuration required and other steps.

The GsDevKit server and client shared installation  may be installed on **Linux** or **Mac**; the instructions are the same for both. You must have 64-Bit Linux (or a 64-bit Linux VM), in order to run GemStone/S 64 Bit. Since these instructions are for installing both client and server on the same node, you cannot setup this for Windwos. If you are running Windows, you can install the server on a Linux VM, and the client on Windows; instructions are [here][4].

####GemStone Version and License
Before running installing the server, please check on the [GemStone/S 64 Bit product page for the latest versions][2] and visit [the Community and Web Edition Licensing page for information on the license included with the download and other options][3]. It is a good idea to acquire a free, Limited Community License by sending email to<EMAIL_ADDRESS>It is also recommended that you download and use the latest version of the GemStone/S 64 Bit product. The following instructions are for version 3.2.9.

###Install Server

The following steps are involved in installing the GsDevKit server and client.  For an example script to execute, see  [Example Script to Install GsDevKit server and client](#example-script-to-install-both-server-and-client).

1. **Determine your installation directory and clone GsDevKit_home to that location**

   The following instructions clone the Development Kit to the current directory, so before starting, cd to the directory in which you want the GsDevKit checkout to be located.

   ```
   cd <githubdirectory>
   git clone https://github.com/GsDevKit/GsDevKit_home.git
   cd GsDevKit_home
   ```

2. **Perform the git checkout and branch**
   ```
   git checkout -b gsdevkit
   ```

3. **Set the environment**

   The environment variable $GS_HOME and the updated $PATH are required to use DevKit, so you should add them to your `.bashrc` or another initialization script.
   ```
   export GS_HOME=<githubdirectory>
   export PATH=$GS_HOME/bin:$PATH
   ```

4. **Perform the Server installation**

    The installation is performed by a GsDevKit script.  This script takes care of cloning the required projects to your server node, installing a stone of the specified version and and specified name, and starting that stone.  You can also use a script that installs the client as well as the server, if you intend to run both components on the same node.

   These instructions use 3.2.9 for `<GemStoneVersion>`; check for more recent [GemStone/S 64 Bit Releases](#gemstone-version-and-license).

   ```
   $GS_HOME/bin/installServerClient -c <authMode> <myStoneName> <myClientName> <GemStoneVersion>
   ```
   You may use any name for the `<myStoneName>` and `<myClientName>`, and note that you may later have multiple stones and multiple clients. The examples below use **devKit_329** and **tode1**. For `<authMode>`, use https, though ssh will also work if you have ssh authentication already set up.

   The install scripts invokes the following sub-scripts:
   ```
   downloadGemStone
   cloneGsDevKitProjects
   cloneSharedTodeProjects
   createStone
   createClient
   ```
   After these scripts successfully complete, you will have a stone named `<myStoneName>`, of GemStone/S 64 Bit version `<GemStoneVersion>`, installed on your server node and running.  You will have a NetLDI named `<myStoneName>_ldi` running on the server, so the server is ready for the tODE client to connect.  You will also have a client named `<myClientName>` installed and ready to start.

## Example Script to Install both Server and Client

This script installs both client and server components, and installs and starts a 3.2.9 server named **devKit_329**, and a todeClient named **tode1**.

```
git clone https://github.com/GsDevKit/GsDevKit_home.git
cd GsDevKit_home
git checkout -b gsdevkit
export GS_HOME=`pwd`
export PATH=$GS_HOME/bin:$PATH
$GS_HOME/bin/installServerClient -c https devKit_329 tode1 3.2.9
```

[1]: ./README.md#installation-on-a-single-desktop
[2]: https://gemtalksystems.com/products/gs64/
[3]: https://gemtalksystems.com/licensing/

[4]: ./README.md#installation-on-separate-server-and-client

gha_language: Shell


text:
---
layout: post
categories: [AWS]
tags: [IoT]

---

AWS IoT is a cloud service that enables the secure communication between IoT devices and AWS cloud.
IoT devices communication with AWS IoT with the [MQTT protocol](http://mqtt.org/), which uses light-weight subscribe/publish
message transport. From the previous figure, we can see that AWS IoT includes the following components:

![AWS IoT](/assets/images/aws_iot_data_services.png)

- **Message broker**: Things report their state to message broker with a specified topic. Message broker sends all messages published on an the topic to all subscribers of this topic.
- **Thing registry**: Thing registry stores information about a thing and the certificates that are used by the thing to secure communication with AWS IoT.
- **Thing shadow**: Each thing has a thing shadow that stores and retrieves state information. Each item in the state information has two entries: the state last reported by the thing and the desired state requested by an application.
- **Rule engine**: You can use rule engine to create rules that define one or more actions, such as send an SQS message, to perform on the data in a message. Rules also contain an IAM role that grants AWS IoT permission to the AWS resources used to perform the action.

extension: markdown


text:
I think emphasis should be used **sparingly**.
That's how you assure *good style*

GitHub's markdown uses TWO _asterisks_ OR _underscores_ for **bold**,
and one for _italics_, but I like using _underscores_ for italics and asterisks for bold,
so I just need to remember to use **TWO* for **bold*

repository: dantho/markdown-portfolio

repo_name: dantho/markdown-portfolio


text:
---
title: Are you Ready for Some Fun? Join Us September 21-22, 2019 for the Bay Area
  Fun Festival!
date: 2019-08-06T11:10:00-07:00
description: 'The end of summer is approaching, but that means the Bay Area Fun Festival
  is happening soon! Join us the weekend of September 21-22, 2019 for a parade, the
  Prefontaine Memorial Run, Cruz the Coos and so much more! '
tags:
- Bay Area Fun Festival
- Beaches
- Charleston
- Coast
- Coos Bay
- North Bend
- Oregon
- recreation
- Steve Prefontaine
categories:
- Fairs & Festivals
image: "/img/bay-area-fun-fest-parade.jpg"

---
The end of summer is approaching, but that means the Bay Area Fun Festival is happening very soon! Visitors from all over the region come out to celebrate with us and take in the sights, sounds and tastes of beautiful downtown Coos Bay and surrounding areas for this popular annual festival.

The Bay Area Fun Festival is sponsored by the [Coos Bay Downtown Association](http://coosbaydowntown.org/) and takes place September 21-22, 2019. Enjoy fun activities including a parade, shopping, tasty food, a car cruise, Prefontaine Memorial Run, and[ live entertainment on the K-DOCK Entertainment Stage](https://bayareafunfestival.com/entertainment/).

Book your accommodations soon so your group can enjoy the fun!

## Featured Events

#### _Cruz the Coos_ Saturday, Sept 21, 2019 at 6:00 p.m.

![](/img/cruz-coos-header.jpg)

Coos Bay-North Bend Rotary, The Mill Casino Hotel & RV Park, KDOCK (KDCQ) 92.9 FM and Bay Area Fun Festival are proud to present a weekend of fun at the [Annual Cruz the Coos and Show ‘n Shine](https://bayareafunfestival.com/cruz-the-coos/).

The event features a Show ‘n Shine in the Mill Casino Hotel Parking Lot followed by the largest car cruise on the Oregon Coast through the streets of downtown Coos Bay. Bring a chair and join the K-DOCK Broadcast Crew at 4th and Central, downtown Coos Bay Saturday night at 6 p.m. for vintage cars and trucks restored to their former glory and some of the greatest music ever made. [www.cruzthecoos.com](https://cruzthecoos.com/)

#### _Bay Area Fun Festival Parade_ - Saturday, Sept 21, 2019 at 1:00 p.m.

![](/img/bay-area-fun-fest-parade.jpg)

Celebrate Coos Bay’s rich history and the 2019 parade theme, “Our Great Outdoors”! The parade line up will start at 4th and Golden Avenue in Coos Bay and begins at 1:00 p.m. Arrive early to get a good spot! [www.bayareafunfestival.com/parade/](https://bayareafunfestival.com/parade/ "https://bayareafunfestival.com/parade/")

#### Prefontaine Run Saturday, Sept 21, 2019

![Steve Prefontaine Annual Run](/img/steve-prefontaine-outdoor-mural.jpg)The ever-popular Prefontaine Memorial Run follows the training route of Coos Bay native and running phenom, Steve Prefontaine. After the run, runners and their guests are encouraged to view the Prefontaine Memorial Gallery at [Coos Art Museum](https://www.coosart.org/). This exhibit is a permanent collection of Steve’s awards and memorabilia, as well as numerous photographs highlighting his illustrious running career. The three-panel mural, pictured above, can be viewed on a building facing Hwy 101 between Anderson and Curtis! [Register Online for the Prefontaine Run. ](https://www.prefontainerun.com/run-information/application.html)

[Click here](https://bayareafunfestival.com/2016-schedule/) to see the full schedule of events. See you in September!

repository: echopdx/coosbay

gha_language: JavaScript

repo_name: echopdx/coosbay