text:
# Creating an App

The development tools provide a command to quickly scaffold a new Rocket.Chat App. Simply run `rc-apps create` and a small form will ask you to provide information about the app you are developing, like its name \(in this example we will call it `liftoff`\), app's description, and developer info. This information will be placed in a file called `app.json` in the project's root folder.

You can check the [app-schema.json](https://github.com/RocketChat/Rocket.Chat.Apps-cli) file for all the detailed information and fields allowed in the app description file, the basic structure is similar to this:

```javascript
{
    "id": "88ce358a-5277-4356-a601-f519574303a4",
    "version": "0.0.1",
    "requiredApiVersion": "^1.4.0",
    "iconFile": "icon.png",
    "author": {
        "name": "rocket.chat",
        "homepage": "rocket.chat",
        "support": "rocket.chat"
    },
    "name": "liftoff",
    "nameSlug": "liftoff",
    "classFile": "LiftoffApp.ts",
    "description": "Tells if it is time to lift off"
}
```

## Start Developing

The basic creation of an App is based on extending the App class from the Rocket.Chat Apps definition library. Your class also has to implement the constructor and optionally the initialize function, for more details on those check the [App definition documentation](https://rocketchat.github.io/Rocket.Chat.Apps-engine/classes/app.app-1.html).

In this example, we already have our main file called `LiftoffApp.ts` that was generated when we first created our project:

```javascript
import {
    IAppAccessors,
    ILogger,
} from<EMAIL_ADDRESS>import { App } from<EMAIL_ADDRESS>import { IAppInfo } from<EMAIL_ADDRESS>
export class LiftoffApp extends App {
    constructor(info: IAppInfo, logger: ILogger, accessors: IAppAccessors) {
        super(info, logger, accessors);
    }
}
```

Now let's add some functionality to it

### Adding a Slashcommand

A Slashcommand is a way to call the app installed in Rocket.Chat. Your app can have multiple slashcommands and subcommands. In our example, we will add the `liftoff` slashcommand and it will be called like this by the user inside the chat:

```text
/liftoff
```

First, we create a new directory called `commands` in our project's root and create a file called `liftoff.ts`. You can copy the file's content:

```javascript
import {ISlashCommand, SlashCommandContext} from<EMAIL_ADDRESS>import {IModify, IRead} from<EMAIL_ADDRESS>import {App} from<EMAIL_ADDRESS>
export class LiftoffCommand implements ISlashCommand {
    public command = 'liftoff';
    public i18nDescription = 'Tells the user if it is time to liftoff';
    public i18nParamsExample = '';
    public providesPreview = false;

    constructor(private readonly app: App) {}

    public async executor(context: SlashCommandContext, read: IRead, modify: IModify): Promise<void> {
        const message = 'Time to lift off!';

        const messageStructure = await modify.getCreator().startMessage();
        const sender = context.getSender(); // the user calling the slashcommand
        const room = context.getRoom(); // the current room

        messageStructure
        .setSender(sender)
        .setRoom(room)
        .setText(message);

        await modify.getCreator().finish(messageStructure);
    }
}
```

> You can learn more about organising complex slash commands in our [Sub-command pattern](../recipes/sub-command-pattern.md) recipe

### Registering the slashcommand

After adding our slashcomamnd logic, we have to register the slashcommand in out app by extending its configuration:

```javascript
import {
    IAppAccessors,
    ILogger,
    IConfigurationExtend,
} from<EMAIL_ADDRESS>import { App } from<EMAIL_ADDRESS>import { IAppInfo } from<EMAIL_ADDRESS>
import { LiftoffCommand } from './commands/liftoff';

export class LiftoffApp extends App {
    constructor(info: IAppInfo, logger: ILogger, accessors: IAppAccessors) {
        super(info, logger, accessors);
    }

    protected async extendConfiguration(configuration: IConfigurationExtend): Promise<void> {
        await configuration.slashCommands.provideSlashCommand(new LiftoffCommand(this));
    }
}
```

We first had to import the `Liftoff` class and then register an instance of using the `provideSlashCommand` function. We pass the app's instance \(`this`\) so our slashcommand have access to all the functionalities of the app.

### Updating the app

If you want to, for example, change the message sent to the room from `Time to lift off!` to `Lift off now!`, you have to simply save the modifications and run:

```text
rc-apps deploy --url http://localhost:3000 --username <your_username> --password <your_password> --update
```

The app will be updated and by sending `/liftoff`, the message will reflect the change you have made in the app.

## Testing the App

Now that you have your App ready, you can test it before submitting it.

To test your app, you need a Rocket.Chat server running locally on your machine and an admin user in it.

See [Installing Rocket.Chat for Developing](../../guides/developer/quick-start-on-linux.md) to run Rocket.Chat in develop mode. Enable Apps development mode by navigating to `Administration > General` then scroll down to Apps and click on the `True` radio button over the Enable development mode.

or run it in preview mode with docker using the command:

```text
docker run -it --rm -p 3000:3000 -v `pwd`/rocketdb:/var/lib/mongodb rocketchat/rocket.chat.preview
```

Having the server running, simply run inside the app project's directory:

```text
rc-apps deploy --url http://localhost:3000 --username user_username --password user_password
```

Where:

`http://localhost:3000` is your local server URL \(if you are running in another port, change the `3000` to the appropriate port\)

`user_username` is the username of your admin user.

`user_password` is the password of your admin user.

If you want to update the app deployed in your Rocket.Chat instance after making changes to it, you can run:

```text
rc-apps deploy --url http://localhost:3000 --username user_username --password user_password --update
```

> After version 1.9 of the App Engine CLI, the `--update` flag isn't strictly necessary for updating an existing App, you can just run the `deploy` command without it.


text:
# Google Software Product Sprint

This repo contains Mitch's portfolio and SPS projects. Stay tuned for more updates!

To get review the opening tutorial login to [Google Cloud Shell](https://ssh.cloud.google.com/cloudshell/editor) and open the GitHub setup walkthrough:

`teachme ~/software-product-sprint/walkthroughs/week-0-setup/github-setup-walkthrough.md`

repository: Mitch-McK/software-product-sprint

branch_name: refs/heads/main

extension: md

gha_language: Java

license_type: permissive

repo_name: Mitch-McK/software-product-sprint


text:
---
layout: post
title: IASSS Surgical Symposium 2015
feature-img: /IASSS2015.jpg
categories: [news,conference]
---
SSAHK is proud to announce the application for the IASSS Surgical Symposium is now open. We will send a team of representatives to Brisbane in July.

This year the 2nd IASSS Surgical Symposium – “Inspiration, Innovation, Action" – Is being held in Brisbane, Australia between Thursday 23rd and Sunday 26th July. This 4 day conference consisting of inspiring keynote speakers, fantastic skills workshops and unforgettable social & networking events.

## Full registration package

- academic plenary sessions
- skills workshops
- welcome cocktails
- scrub run
- trivia night
- gala ball.

## Cost

(excluding flight tickets)

- Full Registration Package: $240 AUD (~$1600 HKD)
- Full registration + Accommodation Package:

The 4 night Hostel accommodation package (Wednesday-Saturday) will be **$200 AUD** per person for 4-6 person rooms with an en-suite and included continental breakfast.

*Total cost: $460 AUD (~$3000 HKD)*

The 4 night Hotel accommodation package (Wednesday-Saturday) will be **$285 AUD** per person for two-bedroom apartments with included breakfast.

*Total cost: $545 AUD (~$3500 HKD)*

## Registration

Quota: 20

Deadline: 25 May 2015

Please apply with SSAHK through this [link](
https://docs.google.com/forms/d/1V4-7cTbg0CtNHRDFmdPioJh7D4G5xEt4TWLx86Zt9IY/viewform).

We will send you a confirmation email shortly.

For more information, please visit the [official website](http://www.iasss2015.org) or official [Facebook Page](https://www.facebook.com/iasss2015brisbane?fref=ts).

license: MIT

branch_name: refs/heads/master


text:
---
layout: slide
title: Web Accessibility
description: Building websites for everyone.
theme: qdelft
highlight: zenburn
transition: slide
---

{% highlight html%}
## Web Accessibility
{% endhighlight %}
___
Building websites for everyone

extension: markdown


text:
---
layout: default
---

# 1996-07-02 - Re: [Fwd: Doubleclick]

## Header Data

From: "Seth I. Rich"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>(Scott Wyant)

Message Hash: 17bffc123d889408c2f10c154a0067ddee59da1f4576ad670331cede2c1d8708

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-07-02 01:21:21 UTC

Raw Date: Tue, 2 Jul 1996 09:21:21 +0800

## Raw message

```
{% raw  %}From: "Seth I. Rich"<EMAIL_ADDRESS>Date: Tue, 2 Jul 1996 09:21:21 +0800
To<EMAIL_ADDRESS>(Scott Wyant)
Subject: Re: [Fwd: Doubleclick]
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

> >> > >If you're like me, you never went to a site called "doubleclick."
> >> > >So how did they give you a cookie?  After all, the idea of the
> >> > >cookie, according to the specs published by Netscape, is to make a
> >> > >more efficient connection between the server the delivers the
> >> > >cookie and the client machine which receives it.
> >> > >But we have never connected to "doubleclick."

You probably loaded a banner ad from doubleclick -- and downloading the
inline image from their site is sufficient for the cookie transfer to
take place.

Seth
---------------------------------------------------------------------------
Seth I. Rich -<EMAIL_ADDRESS>          "Info-Puritan elitist crapola!!"
Systems Administrator / Webmaster, HYGNet<EMAIL_ADDRESS>Rabbits on walls, no problem.

{% endraw %}
```

## Thread

+ Return to [July 1996](/archive/1996/07)

+ Return to "[Scott Wyant <scott_wyant@loop.com>](/authors/scott_wyant_scott_wyant_at_loop_com_)"
+ Return to "["Seth I. Rich" <seth@hygnet.com>](/authors/seth_i_rich_seth_at_hygnet_com_)"

+ 1996-07-01 (Tue, 2 Jul 1996 06:32:38 +0800) - [Re: [Fwd: Doubleclick]](/archive/1996/07/23763e777190d995214c5671fd022bdc341feb18aabb28850540bd702a91926d) - _Scott Wyant<EMAIL_ADDRESS>  + 1996-07-02 (Tue, 2 Jul 1996 09:21:21 +0800) - Re: [Fwd: Doubleclick] - _"Seth I. Rich"<EMAIL_ADDRESS>

gha_license_id: MIT


text:
# AltaCV, yet another LaTeX CV/Résumé class

v1.2 (11 February 2020), by LianTze Lim<EMAIL_ADDRESS>
_Sample file with new paracol layout added on 2 February 2020_

(Thanks to [Nur](https://github.com/nurh) for the name.)

It all started with this:

[](https://twitter.com/Leonduck/status/764281546408923136)

Leonardo was talking about a [résumé of Marissa Mayer that Business Insider put together](http://www.businessinsider.my/a-sample-resume-for-marissa-mayer-2016-7/) using [enhancv.com](https://enhancv.com).
I _knew_ I had to do something about it. And so AltaCV was born.

## Samples

This is how the re-created résumé looks like ([view/open on Overleaf](https://www.overleaf.com/latex/examples/recreating-business-insiders-cv-of-marissa-mayer-using-altacv/gtqfpbwncfvp)):

Though if you're creating your own CV/résumé, you'd probably prefer using the basic template ([view/open on Overleaf](https://www.overleaf.com/latex/templates/altacv-template/trgqjpwnmtgv)):

## Requirements and Compilation

* pdflatex + biber + pdflatex
* AltaCV uses [`fontawesome`](http://www.ctan.org/pkg/fontawesome) and [`academicons`](http://www.ctan.org/pkg/academicons); they're included in both TeX Live 2016 and MikTeX 2.9.
* Loading `academicons` is optional: enable it by adding the `academicons` option to `\documentclass`.
* Use the `normalphoto` option to get normal (i.e. non-circular) photos.
* As of v1.2 you can add multiple photos on the left or right: `\photoL{2cm}{logo1}` and `\photoR{2.5cm}{logo2,photo}`. (`\photo` will work like `\photoR`.) Separate your image filenames with commas _without_ spaces.
* Use the `ragged2d` option to activate hyphenations while keeping text left-justified; line endings will thus be less jagged and more aesthetically pleasing.
* Can now be compiled with pdflatex, XeLaTeX and LuaLaTeX!
* However if you're using `academicons`, you _must_ use either XeLaTeX or LuaLaTeX. If the doc then compiles but the icons don't show up in the output PDF, try compiling with LuaLaTeX instead.
* The samples here use the [Lato](http://www.latofonts.com/lato-free-fonts/) font. Feel free to use a different typeface package instead—often a different typeface will change the entire CV's feel.

## Example Files

### `sample.tex`

(You may prefer to use `sample-alt.tex` instead; please read both sections before proceeding.)

This is the original sample template file. The right sidebar is actually a _marginpar_, so it doesn't support footnote and cannot automatically break across pages if it's too long. You would need to split your right sidebar contents into separate files e.g. `p1sidebar.tex` and `p2sidebar.tex`, and insert them as the optional argument of the `\cvsection{...}` that you want to align them with:

```latex
\cvsection[p1sidebar]{Experience}
...
... END OF FIRST PAGE OF YOUR CV ...
\cvsection[page2sidebar]{Publications}
...
```

This assumes that the next page's main column would start immediately with a `\cvsection`, so that the top of your right sidebar contents also appear at the top of the page. Now if the _next_ page doesn't start with a `\cvsection` but you'd still like to add a sidebar, then use this command on the _current_ page to add it. The optional argument lets you pull up the sidebar a bit so that it looks aligned with the top of the main column:

```latex
\addnextpagesidebar[-1ex]{page3sidebar}
```

If you want to change the left and right columns' widths, you'll need to tinker with the `right` (distance from paper's right edge until the main column's right edge) and `marginparwidth` (width of the right sidebar) options in the `\geometry` line. For example, to make the right sidebar wider by 2cm, you could use

```latex
%% original was right=9cm, marginparwidth=6.8cm
\geometry{left=1cm,right=11cm,marginparwidth=8.8cm,marginparsep=1.2cm,top=1cm,bottom=1cm}
```
as well as doing a bit of arithmetic when you're making the header to get it full-width, i.e. reducing the sidebar by 2cm and extending the main column by 2cm.

```latex
\begin{adjustwidth}{}{-10cm}  %% original was -8cm
\makecvheader
\end{adjustwidth}
```

### `sample-alt.tex` [ADDED 2 FEBRUARY 2020]
Many users have overlooked the optional argument of `\cvsection` to insert the right sidebar contents, and often confused that the right sidebar doesn't automatically break across pages. This new layout uses the `paracol` package for typesetting the left and right columns that _can_ break across pages. It also makes changing the column widths easier:

```latex
%% Set the left/right column width ratio to 6:4.
\columnratio{0.6}

% Start a 2-column paracol. Both the left and right columns will automatically
% break across pages if things get too long.
\begin{paracol}{2}
\cvsection{Experience}
...
... END OF LEFT COLUMN CONTENTS ...

% Now switch to the right column.
\switchcolumn
\cvsection{Education}
...
...END OF RIGHT COLUMN CONTENTS ...
\end{paracol}
```
You can also use `\swithcolumn*` for "synchronising" the columns, as well as other commands from the `paracol` package. See the [`paracol` package documentation](http://texdoc.net/pkg/paracol) for further details.


text:
# Large Hadron Migrator

[![Tests](https://github.com/Shopify/lhm/actions/workflows/test.yml/badge.svg)](https://github.com/Shopify/lhm/actions/workflows/test.yml)

This is the Shopify fork of [SoundCloud's LHM](https://github.com/soundcloud/lhm). The
following description, originally from SoundCloud (with minor updates by Shopify),
gives some of the flavor around its original creation, and its choice of name...

 Most Rails projects start like this, and at first, making
changes is fast and easy.

That is, until your tables grow to millions or billions of records. At this point,
the locking nature of `ALTER TABLE` may take your site down for hours or more
while critical tables are migrated. In order to avoid this, developers begin
to design around the problem by introducing join tables or moving the data
into another layer. Development gets less and less agile as tables grow and
grow. To make the problem worse, adding or changing indices to optimize data
access becomes just as difficult.

*Side effects may include black holes and universe implosion.*

There are few things that can be done at the server or engine level. It is
possible to change default values in an `ALTER TABLE` without locking the
table. InnoDB provides facilities for online index creation, but that only
solves half the problem.

At SoundCloud we started having migration pains quite a while ago, and after
looking around for third party solutions, we decided to create our
own. We called it **Large Hadron Migrator**, and it is a Ruby Gem that provides
facilities for online ActiveRecord migrations.

![The Large Hadron Collider at CERN](http://farm4.static.flickr.com/3093/2844971993_17f2ddf2a8_z.jpg)

The [Large Hadron Collider](http://en.wikipedia.org/wiki/Large_Hadron_Collider) at [CERN](https://en.wikipedia.org/wiki/CERN) near Geneva, Switzerland.

## The idea

The basic idea is to perform the migration online while the system is live,
without locking the table. In contrast to [OAK][0] and the [facebook tool][1], we
only use a copy table and triggers.

LHM is a test-driven Ruby solution which can easily be dropped into an ActiveRecord
migration. It presumes a single auto-incremented numeric primary key called `id` as
per the Rails convention. Unlike [Matt Freels's `table_migrator` solution][2],
it does not require the presence of an indexed `updated_at` column.

## Requirements

LHM currently only works with MySQL databases and requires an established
ActiveRecord connection.

## Limitations

Due to the Chunker implementation, LHM requires that the table to migrate has a
a single integer numeric key column named `id`.

## Installation

Install it via `gem install lhm-shopify` or by adding `gem "lhm-shopify"` to your `Gemfile`.

## Usage

You can invoke LHM directly from a plain Ruby file after connecting ActiveRecord
to your MySQL instance:

```ruby
require 'lhm'

ActiveRecord::Base.establish_connection(
  :adapter => 'mysql',
  :host => '<IP_ADDRESS>',
  :database => 'lhm'
)

# and migrate
Lhm.change_table :users do |m|
  m.add_column :arbitrary, "INT(12)"
  m.add_index  [:arbitrary_id, :created_at]
  m.ddl("alter table %s add column flag tinyint(1)" % m.name)
end
```

To use LHM from an `ActiveRecord::Migration` in a Rails project, add it to your
`Gemfile`, then invoke as follows:

```ruby
require 'lhm'

class MigrateUsers < ActiveRecord::Migration
  def self.up
    Lhm.change_table :users do |m|
      m.add_column :arbitrary, "INT(12)"
      m.add_index  [:arbitrary_id, :created_at]
      m.ddl("alter table %s add column flag tinyint(1)" % m.name)
    end
  end

  def self.down
    Lhm.change_table :users do |m|
      m.remove_index  [:arbitrary_id, :created_at]
      m.remove_column :arbitrary
    end
  end
end
```

**Note:** LHM does not delete the old, leftover table. This is intentional, in order
to prevent accidental data loss. After successful or failed LHM migrations, these leftover
tables must be cleaned up.

### Usage with ProxySQL
LHM can recover from connection loss. However, when used in conjunction with ProxySQL, there are multiple ways that
connection loss could induce data loss (if triggered by a failover). Therefore  it will perform additional checks to
ensure that the MySQL host stays consistent across the schema migrations if the feature is enabled.
This is done by tagging every query with `/*maintenance:lhm*/`, which will be recognized by ProxySQL.
However, to get this feature working, a new ProxySQL query rule must be added.
```cnf
{
  rule_id = <rule id>
  active = 1
  match_pattern = "maintenance:lhm"
  destination_hostgroup = <MySQL writer's hostgroup>
}
```

This will ensure that all relevant queries are forwarded to the current writer.

Also, ProxySQL disables [multiplexing](https://proxysql.com/documentation/multiplexing/) for `select` on `@@` variables.
Therefore, the following rules must be added to ensure that queries (even if tagged with `/*maintenance:lhm*/`) get
forwarded to the right target.
```cnf
{
  rule_id = <rule id>
  active = 1
  match_digest = "@@global\.server_id"
  multiplex = 2
},
{
  rule_id = <rule id>
  active = 1
  match_digest = "@@global\.hostname"
  multiplex = 2
}
```

Once these changes are added to the ProxySQL configuration (either through `.cnf` or dynamically through the admin interface),
the feature can be enabled. This is done by adding this flag when providing options to the migration:
```ruby
 Lhm.change_table(..., options: {reconnect_with_consistent_host: true}) do |t|
  ...
end
```
**Note**: This feature is disabled by default

## Throttler

LHM uses a throttling mechanism to read data in your original table. By default, 2,000 rows are read each 0.1 second. If you want to change that behaviour, you can pass an instance of a throttler with the `throttler` option. In this example, 1,000 rows will be read with a 10 second delay between each processing:

```ruby
my_throttler = Lhm::Throttler::Time.new(stride: 1000, delay: 10)

Lhm.change_table :users, throttler: my_throttler  do |m|
  ...
end
```

### ReplicaLag Throttler

Lhm uses by default the time throttler, however a better solution is to throttle the copy of the data
depending on the time that the replicas are behind. To use the ReplicaLag throttler:

```ruby
Lhm.change_table :users, throttler: :replica_lag_throttler  do |m|
  ...
end
```

Or to set that as default throttler, use the following (for instance in a Rails initializer):

```ruby
Lhm.setup_throttler(:replica_lag_throttler)
```

### ThreadsRunning Throttler

If you don't have access to connect directly to your replicas, you can also
throttle based on the number of threads running in MySQL, as a proxy for "is
this operation causing excessive load":

```ruby
Lhm.change_table :users, throttler: :threads_running_throttler do |m|
  ...
end
```

Or to set that as default throttler, use the following (for instance in a Rails initializer):

```ruby
Lhm.setup_throttler(:threads_running_throttler)
```

## Table rename strategies

There are two different table rename strategies available: `LockedSwitcher` and
`AtomicSwitcher`.

The `LockedSwitcher` strategy locks the table being migrated and issues two `ALTER TABLE` statements. The `AtomicSwitcher` uses a single atomic `RENAME TABLE` query and is the favored solution.

LHM chooses `AtomicSwitcher` if no strategy is specified, **unless** your version of MySQL is
affected by [binlog bug #39675](http://bugs.mysql.com/bug.php?id=39675). If your version is
affected, LHM will raise an error if you don't specify a strategy. You're recommended
to use the `LockedSwitcher` in these cases to avoid replication issues.

To specify the strategy in your migration:

```ruby
Lhm.change_table :users, :atomic_switch => true do |m|
  ...
end
```

## Limiting the data that is migrated

For instances where you want to limit the data that is migrated to the new
table by some conditions, you may tell the migration to filter by a set of
conditions:

```ruby
Lhm.change_table(:sounds) do |m|
  m.filter("inner join users on users.`id` = sounds.`user_id` and sounds.`public` = 1")
end
```

Note that this SQL will be inserted into the copy directly after the `FROM` clause
so be sure to use `INNER JOIN` or `OUTER JOIN` syntax and not comma-joins. These
conditions will not affect the triggers, so any modifications to the table
during the run will happen on the new table as well.

## Cleaning up after an interrupted Lhm run

If an LHM migration is interrupted, it may leave behind the temporary tables
and/or triggers used in the migration. If the migration is re-started, the
unexpected presence of these tables will cause an error.

In this case, `Lhm.cleanup` can be used to drop any orphaned LHM temporary tables or triggers.

To see what LHM tables/triggers are found:

```ruby
Lhm.cleanup
```

To remove any LHM tables/triggers found:

```ruby
Lhm.cleanup(true)
```

Optionally, only remove tables up to a specific time, if you want to retain previous migrations.

Rails:

```ruby
Lhm.cleanup(true, until: 1.day.ago)
```

Ruby:

```ruby
Lhm.cleanup(true, until: Time.now - 86400)
```

## Contributing

To run the tests:

```bash
bundle exec rake unit # unit tests
bundle exec rake integration # integration tests
bundle exec rake unit # all tests
```

You can run an individual test as follows:

```bash
bundle exec rake unit TEST=spec/integration/atomic_switcher_spec.rb
```

You can check the code coverage reporting for an individual test as follows:

```bash
rm -rf coverage
COV=1 bundle exec rake unit TEST=spec/integration/atomic_switcher_spec.rb
open coverage/index.html
```

To check the code coverage for all tests:

```bash
rm -rf coverage
COV=1 bundle exec rake unit && bundle exec rake integration
open coverage/index.html
```

### Merging for a new version
When creating a PR for a new version, make sure that th version has been bumped in `lib/lhm/version.rb`. Then run the following code snippet to ensure the everything is consistent, otherwise
the gem will not publish.
```bash
bundle install
bundle update
bundle exec appraisals install
```

### Podman Compose
The integration tests rely on a replication configuration for MySQL which is being proxied by an instance of ProxySQL.
It is important that every container is running to execute the integration test suite.

## License

The license is included as [LICENSE](LICENSE) in this directory.

## Similar solutions

  * [OAK: online alter table][0]
  * [Facebook][1]
  * [Twitter][2]
  * [pt-online-schema-change][3]

[0]: https://shlomi-noach.github.io/openarkkit/introduction.html
[1]: http://www.facebook.com/note.php?note\_id=430801045932
[2]: https://github.com/freels/table_migrator
[3]: http://www.percona.com/doc/percona-toolkit/2.1/pt-online-schema-change.html
[4]: https://travis-ci.org/soundcloud/lhm
[5]: https://travis-ci.org/soundcloud/lhm.svg?branch=master

repository: Shopify/lhm

gha_language: Ruby

repo_name: Shopify/lhm


text:
---
title: BookGen
repo: webmaster442/BookGen
homepage: https://github.com/webmaster442/BookGen
language:
  - C#
license:
  - MIT
templates:
  - HTML
description: A static site generator inspired by the GitBook toolchain.
---

[BookGen](https://github.com/webmaster442/BookGen) is a command line toolchain for writing books and documentation in markdown. It was inspired by GitBook.

It is designed to be cross platform, but It's developed and tested under Windows. It features a web based, cross platform Markdown editor.

# Features

- Written in C#, targets .NET Core 3.1
- Extremely fast, compared to GitBook and other NodeJs stuff
- It hasn't got a template engine, so you don't have to learn a new template language. However it's extendable via shortcodes, like wordpress
- Can be extended with Scripting API
- Can be extended with NodeJs Scripts
- Many output formats:
    - Static website with Bootstrap template
    - Printable or Word processor importable plain HTML
    - EPub v. 3.0
    - Wordpress compatible XML export file


text:
# Step 2 - IoT Core

> Approximate time: 20-25 minutes

## Before you start
 * Connect your Pi to the network
 * Boot it up
 * Once up and running, identify IP
 * `ssh` into it
 * once connected, proceed to the next step.

> **Please ensure you are able to connect to the pi, moving forward without being able to ssh into the pi, will not let you try out the lab.**

#### Refresher: Boot, Identify Pi on network

Plug in an ethernet cable into your pi, and wait 1 minute after boot to start looking for the pi on the network

A more detailed write up for [identifing your IP](https://www.raspberrypi.org/documentation/remote-access/ip-address.md) is documented on the offical website.

#### Resolving `<YOUR_PI_NAME>.local` with mDNS
 * Open terminal
 * Type `ping <YOUR_PI_NAME>.local`
 * If the Raspberry Pi is reachable, `ping` will show its IP address
```
  PING <YOUR_PI_NAME>.local (<IP_ADDRESS>): 56 data bytes
  64 bytes from <IP_ADDRESS>: icmp_seq=0 ttl=255 time=2.618 ms
```
----

## 1a. AWS IoT Console

### What are we doing here ?
 * Register our device (thing) with AWS console.
 * Create IoT policy
 * Attach certificate to IoT policy
 * Attach certificate to thing

Now that you have your Pi up and running, lets setup the **IoT Core** on the AWS console. Where ever the document says `<YOURNAME>`, replace it with your name or a user friendly name, which can help you identify your device and policies later.

> *If the commit date on this is older than 6 months, please also refer the [offical documentation](https://docs.aws.amazon.com/iot/latest/developerguide/what-is-aws-iot.html) for any new updates.*

The steps are borrowed & short formed from the orignal [**AWS documentation**](https://docs.aws.amazon.com/iot/latest/developerguide/register-device.html)

### Create Policy
 * On your current machine, browse to the [**AWS IoT console**](https://console.aws.amazon.com/iot/home).
 * In the navigation pane, choose **Secure**, and then choose **Policies**.
 * On the **Policies** page, choose **Create a policy**.
 * On the **Create a policy** page:
 * Enter a **name** for the policy (for example, `<YOURNAME>-Policy`).
 * For **Action**, enter `iot:*`
 * For **Resource ARN**, enter `*`
 * Under **Effect**, choose **Allow**, and then choose **Create**.
 * This policy allows your Raspberry Pi to publish messages to AWS IoT.

> **Important** These settings are overly permissive. In a production environment narrow the scope of the permissions to that which are required by your device.

### Register Device (Thing)
 * In the console navigation pane, choose **Manage**, and then choose **Things**.
 * Choose **Create**.
 * On the **Creating AWS IoT things** page, choose **Create a single thing**.
 * On the **Add your device** to the device registry page, enter **`<YOURNAME>`_PI**, and then choose **Next**.

### Generate & Attach Certificates
Certificates are what ensures a secure communication between your Pi and the cloud services. In this step, we generate certificates and install them on the pi.

 * On the **Add a certificate** for your thing page, choose **Create certificate**.
 * On the **Certificate created** page, download your `private key`, `device certificate`, and a `root certificate authority (CA)` for AWS IoT. (Choose the Download link for each)
  > These files are saved in your downloads directory.
 * Choose **Activate** to activate the X.509 certificate, and then choose **Attach a policy**.
 * On the **Add a policy** for your thing page, choose `<YOURNAME>-Policy` and then choose **Register Thing**.

----

## 1b. The Pi

> **IMPORTANT: Please ensure you are able to connect to the pi, moving forward without being able to ssh into the pi, is be a blocker for this lab.**

> For the following steps, you can either `ssh` into the pi and make changes there, or make changes on your local and `scp` the files to the pi
>
> Feel free to substitute `vim` with your [favourite text editor](https://xkcd.com/1823/)

### Certificate installation

 * Open terminal
 * `ssh` into the pi
    ```
    ssh pi@<IP_ADDRESS>
    password: <SUPER_SECRET_PASSWORD>
    ```
 * Create a working directory under `/home/pi`, this is where we'll copy our certificates and python code.
 ```
 mkdir -p /home/pi/iot/certs
 ```
 * Move the downloaded certificates your `private key`, `device certificate`, and a `root certificate authority (CA)` on your local machine to a single empty folder for easier transfer.
 * `scp` or WinSCP the certificate files to `/home/pi/iot/certs`. Run this on local machine, to transfer to pi.
 ```
 cd <certs_folder>

 scp * pi@<YOUR_PI_IP>:~/iot/certs
 ```
 * You now have your certificates on the pi
 * Make symlinks with user friendly names
 ```
  ln -s /home/pi/iot/certs/<YOUR_KEY>private.pem.key /home/pi/iot/certs/private.pem.key
  ln -s /home/pi/iot/certs/<YOUR_KEY>certificate.pem.crt /home/pi/iot/certs/certificate.pem.crt
 ```
 * Download the config.py file from `code/pi/src/config.py` github to your local machine at `/home/pi/iot`
 ```
 wget https://raw.githubusercontent.com/varunmehta/dive-into-iot/master/code/pi/src/config.py
 wget https://raw.githubusercontent.com/varunmehta/dive-into-iot/master/code/pi/src/main.py
  ```

### Modify `config.py`
`config.py` has all the modifiable parameters, which are specific to your setup. We'll change some of the parameters as we've set them up for now.

#### End Point URL

Your Thing has an iot end point, it gets assigned a unique id, which is part of the url.

* Go to list of **Things**
* Click on your **Thing**
* Select **Interact** from the menu on the left.
* Check the `url` under **HTTPS**

Replace the `<URL>` under `HOST_NAME` to the valid id.
```
# AWS IoT endpoint settings
HOST_NAME = "<URL>-ats.iot.us-east-1.amazonaws.com"
```

#### Verify certificate paths

Just to make things easier, we've already created symlinks to the certs and keys, please ensure the files exist on the path, and the paths specified in the config is valid.
```
# Thing certs & keys
PRIVATE_KEY = "/home/pi/iot/certs/private.pem.key"
DEVICE_CERT = "/home/pi/iot/certs/certificate.pem.crt"
ROOT_CERT = "/home/pi/iot/certs/root-CA.crt"
```

#### MQTT Topics
Replace `<YOUR_THING_NAME>` with the name of the thing you set in the AWS console.
```
# Message settings
PHOTO_RESISTOR_SENSOR = "$aws/things/<YOUR_THING_NAME>/sensor"
FLASHER = "$aws/things/<YOUR_THING_NAME>/flasher"
```

## Next --> [03 - Build AWS supporting infrastructure](../03-infrastructure)
This concludes our setup of the basic IoT Core on the console and Pi. Let build the supporting AWS infrastructure to get to the cloud...

repository: varunmehta/dive-into-iot

gha_language: Python

repo_name: varunmehta/dive-into-iot


text:
# Beelzebul

## Facts:

Beelzebul is another name for Satan, or the devil. It is also sometimes spelled, “Beelzebub.”

* This name literally means “lord of flies” which means “ruler over demons.” But it is best to translate this term close to the original spelling rather than translate the meaning.
* It could also be translated as “Beelzebul the devil” to make it clear who is being referred to.
* This name is related to the name of the false god “Baal-zebub” of Ekron.

(Translation suggestions: [How to Translate Names](../../translate/translate-names))

(See also: [demon](../kt/demon.md), [Ekron](../names/ekron.md), [Satan](../kt/satan.md))

## Bible References:

* [Luke 11:15](rc://en/tn/help/luk/11/15)
* [Mark 3:22](rc://en/tn/help/mrk/03/22)
* [Matthew 10:25](rc://en/tn/help/mat/10/25)
* [Matthew 12:25](rc://en/tn/help/mat/12/25)

## Word Data:

* Strong’s: [[G00954]]

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# Queuel

[![Gem Version](https://badge.fury.io/rb/queuel.png)](http://badge.fury.io/rb/queuel)
[![Build Status](https://travis-ci.org/sportngin/queuel.png?branch=master)](https://travis-ci.org/sportngin/queuel)
[![Code Climate](https://codeclimate.com/github/sportngin/queuel.png)](https://codeclimate.com/github/sportngin/queuel)
[![Coverage Status](https://coveralls.io/repos/sportngin/queuel/badge.png)](https://coveralls.io/r/sportngin/queuel)

Queuel is a 'kewl', lite wrapper around Queue interfaces. Currently it implements:

* IronMQ
* Amazon SQS
* Null pattern

Each of these should reliably implement:

* `push`
* `pop`
* `receive`

Along with some further conveniences.

# Installation

Add this line to your application's Gemfile as well as the proper Gem for
your queuing:

```ruby
gem 'iron_mq' # if using IronMQ
gem 'aws-sdk' # if using Amazon SQS
gem 'aws-sdk-v1' # if using Amazon SQS but you are already using AWS and need to continue using v2
# IronMQ recommends `gem "typhoeus"` as well for some speed benefits
gem 'queuel'
```

And then execute:

```bash
$ bundle
```

You will then want to configure:

```ruby
Queuel.configure do
  # Optional, but a queue must be selected before running put/pop/receive
  default_queue :venues

  # requirement depends on your Queue
  credentials token: 'asdufasdf8a7sd8fa7sdf', project_id: 'project_id'

  # currently [:iron_mq, :sqs, :null] available
  engine :iron_mq

  # For Queuel.recevier {} you can configure more than one thread to
  # handle incoming messages
  receiver_threads 3 # default: 1

  # Logging: Default is MonoLogger, because its a non-blocking log-extension
  # To the standard lib Logger. Any Log4r solution should work.
  logger Logger # default: MonoLogger.new(STDOUT)

  log_level MonoLogger::DEBUG # default: MonoLogger::ERROR # => 3

  # Incoming messages can be automatically encoded/decoded
  decode_by_default false # default: true
  decoder ->(body) { MultiJson.load body } # default: Queuel::Serialization::Json::Decoder

  encode_by_default false # default: true
  encoder ->(body) { body.to_s } # default: Queuel::Serialization::Json::Encoder
end
```

# Usage

### General Queue API

```ruby
# Using default Queue from config
Queuel.pop
Queuel.push "My message to you"
Queuel.receive do |message|
  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
end

# With the non-default queue
Queuel.with("officials").pop
Queuel.with("officials").push "My message to you"
Queuel.with("officials").receive do |message|
  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
end

# Break on nil
Queuel.receive break_if_nil: true do |message|
  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
end
```

#### Caveats of the receiver

* Your block must return true in order to not replace the message to the Queue

#### SQS s3 fallback

Currently the SQS engine is the only engine with the s3 fallback support and
takes the following keys:

* `s3_access_key_id`
* `s3_secret_access_key`
* `s3_bucket_name`
* `max_bytesize` (optional)

With these in place, messages over the `max_bytesize` (defaults to 64kb) will
be sent to the designated bucket.  Without this in place, messages over SQS's
limit be dropped from the queue.

### The message

```ruby
message.id        # => ID of the message
message.raw_body  # => Raw Message body
message.body      # => Message body (parsed, if configured to do so)
message.delete    # => Delete the message
```

#### Parsing

Queuel uses [MultiJson](https://github.com/intridea/multi_json) to provide
some auto-message decoding/encoding features. With MultiJson you may install your own engine
(like [Oj](https://github.com/ohler55/oj)).

Because of the parsing given, you will default to encoding and decoding JSON:

```ruby
Queuel.push username: "jon"
Queuel.pop # => { username: "jon" }
```

You can configure your decoder/encoder on the fly:

```ruby
Queuel.push { username: "jon" }, encoder: ->(body) {  }
Queuel.pop decoder: ->(raw) { }
Queuel.receive decoder: ->(raw) { }
```

You can turn of encoding/decoding at calltime with:

```ruby
Queuel.push { username: "jon" }, encode: false
Queuel.pop decode: false
Queuel.receive decode: false
```

# Contributing

1. Fork it
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 new Pull Request

repository: sportngin/queuel

repo_name: sportngin/queuel


text:
# s3-bucket-tagger
Simple script written in Python 3 that will add tags to the given buckets in an AWS account.

## Prerequisites

Following Python 3 libraries are required.
```
boto3
botocore
```

AWS named profile and credentials should be configured - [Read more](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)

## Installation

* Clone the git repository
```
git clone git@github.com:thilinajayanath/s3-bucket-tagger.git
```

It is recommended to use a Python 3 virtual environment to install the above libraries [Read more](https://docs.python.org/3/library/venv.html)
Required libraries can be installed with the requirements.txt file to the virtual environment [Read more](https://pip.pypa.io/en/stable/user_guide/#requirements-files)

```
python3 -m venv /path/to/new/virtual/environment
/path/to/new/virtual/environment/bin/pip install -r requirements.txt
```

## Format of the csv file with tags
Please refer the example.csv file.

The csv file containing the tags should be in the following format.

Header of the csv file
```
bucket_name,key1,key2,etc..
```

Values
```
<bucket-name>,tag1,tag2
```

## Run the application

```
cd s3-bucket-tagger
chmod u+x s3-bucket-tagger.py
/path/to/new/virtual/environment/bin/python s3-bucket-tagger.py <AWS-PROFILE-NAME> <TAG-LIST-AS-CSV>
```

## License

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


text:
// Databricks notebook source exported at Tue, 28 Jun 2016 09:30:18 UTC

# [Scalable Data Science](http://www.math.canterbury.ac.nz/~r.sainudiin/courses/ScalableDataScience/)

### prepared by [Raazesh Sainudiin](https://nz.linkedin.com/in/raazesh-sainudiin-45955845) and [Sivanand Sivaram](https://www.linkedin.com/in/sivanand)

*supported by* [![](https://raw.githubusercontent.com/raazesh-sainudiin/scalable-data-science/master/images/databricks_logoTM_200px.png)](https://databricks.com/)
and
[![](https://raw.githubusercontent.com/raazesh-sainudiin/scalable-data-science/master/images/AWS_logoTM_200px.png)](https://www.awseducate.com/microsite/CommunitiesEngageHome)

The [html source url](https://raw.githubusercontent.com/raazesh-sainudiin/scalable-data-science/master/db/week9/17_SparklingWater/031_H2O_sparkling_water.html) of this databricks notebook and its recorded Uji ![Image of Uji, Dogen's Time-Being](https://raw.githubusercontent.com/raazesh-sainudiin/scalable-data-science/master/images/UjiTimeBeingDogen.png "uji"):

[![sds/uji/week9/17_SparklingWater/031_H2O_sparkling_water](http://img.youtube.com/vi/iDyeK3GvFpo/0.jpg)](https://www.youtube.com/v/iDyeK3GvFpo?rel=0&autoplay=1&modestbranding=1&start=3093&end=3669)

# Deep learning with H2O.ai and Spark
* This notebook provides an introduction to the use of Deep Learning algorithms with H2O.ai and Spark
* It introduces H2O.ai a distributed machine learning framework
* It shows an example deep learning application written in H2O.ai (Sparkling water) and Spark

#### H2O features - overview
[http://www.h2o.ai/product/downloads/recommended-systems.pdf](http://www.h2o.ai/product/downloads/recommended-systems.pdf)
***

* H2O Core
* H2O Flow
* Algorithms
* Sparkling Water
* H2O Frame

###H2O.ai - Architecture
[https://github.com/h2oai/h2o-3/blob/master/h2o-docs/src/product/architecture/Architecture.md](https://github.com/h2oai/h2o-3/blob/master/h2o-docs/src/product/architecture/Architecture.md)

![H2O.ai - Architecture](https://raw.githubusercontent.com/h2oai/h2o-3/master/h2o-docs/src/product/architecture/images/h2o_stack.png)

-- Image Credit: Sparkling water

### H2O Flow

**Watch later (2:28 seconds)**:

[![H2O Flow](http://img.youtube.com/vi/wzeuFfbW7WE/0.jpg)](https://www.youtube.com/v/wzeuFfbW7WE?rel=0&autoplay=1&modestbranding=1)

###Algorithms

####Supervised Learning
* Generalized Linear Modeling (GLM): [Tutorial](http://learn.h2o.ai/content/tutorials/glm/glm.html?_ga=1.123084171.1438470624.1462131663) | [Reference](http://h2o-release.s3.amazonaws.com/h2o/latest_stable_GLM_booklet.html)
* Gradient Boosting Machine (GBM):  [Tutorial](http://learn.h2o.ai/content/tutorials/gbm-randomforest/index.html?_ga=1.60642349.1438470624.1462131663) | [Reference](http://h2o-release.s3.amazonaws.com/h2o/latest_stable_GBM_booklet.html)
* Deep Learning: [Tutorial](http://learn.h2o.ai/content/tutorials/deeplearning/index.html?_ga=1.127736589.1438470624.1462131663) | [Reference](http://h2o-release.s3.amazonaws.com/h2o/latest_stable_DeepLearning_booklet.html)
* Ensembles (Stacking): [Tutorial](http://learn.h2o.ai/content/tutorials/ensembles-stacking/index.html?_ga=1.127736589.1438470624.1462131663) |  [Reference](https://github.com/h2oai/h2o-3/blob/master/h2o-r/ensemble/README.md)
* Distributed Random Forest:  [Tutorial](https://github.com/h2oai/h2o-3/blob/master/h2o-docs/src/product/tutorials/rf/rf.md)
* Naive Bayes: [Reference](http://h2o-release.s3.amazonaws.com/h2o/rel-turchin/3/docs-website/h2o-docs/index.html#Data%20Science%20Algorithms-Na%C3%AFve%20Bayes)
***

####Unsupervised Learning
* Generalized Low Ranked Modeling (GLRM):  [Tutorial](http://learn.h2o.ai/content/tutorials/glrm/glrm-tutorial.html?_ga=1.127908877.1438470624.1462131663) |  [Reference](http://arxiv.org/abs/1410.0342)
* K-Means:  [Tutorial](https://github.com/h2oai/h2o-3/blob/master/h2o-docs/src/product/tutorials/kmeans/kmeans.md)
* PCA:  [Tutorial](https://github.com/h2oai/h2o-3/blob/master/h2o-docs/src/product/tutorials/pca/pca.md)
* Anomaly Detection via Deep Learning: [Tutorial](https://github.com/h2oai/h2o-training-book/blob/master/hands-on_training/anomaly_detection.md)

###H2O.ai - Sparkling water
[https://github.com/h2oai/sparkling-water/blob/master/DEVEL.md](https://github.com/h2oai/sparkling-water/blob/master/DEVEL.md)

![H2O.ai - Sparkling water](https://raw.githubusercontent.com/h2oai/sparkling-water/master/design-doc/images/Sparkling%20Water%20cluster.png)

-- Image Credit: Sparkling water

#####Data sharing between RDD, DataFrame and H2OFrame

![H2O.ai - Sparkling water](https://raw.githubusercontent.com/h2oai/sparkling-water/master/design-doc/images/DataShare.png)

-- Image Credit: Sparkling water

### APIs
* [Core API](http://h2o-release.s3.amazonaws.com/h2o/rel-turchin/3/docs-website/h2o-core/javadoc/index.html)
* [Algorithms](http://h2o-release.s3.amazonaws.com/h2o/rel-turchin/3/docs-website/h2o-algos/javadoc/index.html)
* [Models](http://h2o-release.s3.amazonaws.com/h2o/rel-turchin/3/docs-website/h2o-genmodel/javadoc/index.html)
***

[Deep learning booklet](http://h2o-release.s3.amazonaws.com/h2o/rel-turchin/3/docs-website/h2o-docs/booklets/DeepLearning_Vignette.pdf)

# [Scalable Data Science](http://www.math.canterbury.ac.nz/~r.sainudiin/courses/ScalableDataScience/)

### prepared by [Raazesh Sainudiin](https://nz.linkedin.com/in/raazesh-sainudiin-45955845) and [Sivanand Sivaram](https://www.linkedin.com/in/sivanand)

*supported by* [![](https://raw.githubusercontent.com/raazesh-sainudiin/scalable-data-science/master/images/databricks_logoTM_200px.png)](https://databricks.com/)
and
[![](https://raw.githubusercontent.com/raazesh-sainudiin/scalable-data-science/master/images/AWS_logoTM_200px.png)](https://www.awseducate.com/microsite/CommunitiesEngageHome)

license: Unlicense

repository: SheperoMah/scalable-data-science

gha_license_id: Unlicense

repo_name: SheperoMah/scalable-data-science


text:
# SQLAnywhere2 - A modern, simple SQLAnywhere library for Ruby

SQLAnywhere2 is meant to simplify the process of connecting and executing queries.
SQLAnywhere2 methods are designed to not be blocking.

It does not map 1 to 1 with SQLAnywhere libdbcapi, instead it provides a simple api for connection and query execution.
It also does not support multirow fetching since libdbcapi multi fetching is buggy and sometimes does not return correct results.

__Warning__ libdbcapi does not support execution of queries with procedures which contain INOUT parameters.
If such procedure is used it seldom leads to a ruby VM crash. More info on this below.

__Warning__ libdbcapi does not support preparing statements with more than 32767 params(16-bit integer limit).
If an SQL with this many parameters is prepared, it will lead to a ruby VM crash.

It requires specifing connection encoding for correct translation from returned sql data to ruby.

The API consists of three classes:

`SQLAnywhere2::Connection` - for making a connection with your database.
`SQLAnywhere2::Statement` - returned after executing `execute_direct` or `prepare` on the connection.
`SQLAnywhere2::Result` - returned after executing a query which returns a result set.

## Installing

In your Gemfile

`gem 'sqlanywhere2', github: 'Unact/sqlanywhere2'`

## Usage

Connect to a database:

```ruby
connection = SQLAnywhere2::Connection.new(
  conn_string: "ServerName=MyServer;DatabaseName=MyDatabase;UserID=root;Password=pwd;CharSet=UTF-8;"
)
```

Querying:

```ruby
statement, results = connection.execute_direct("SELECT * FROM products")
```

Since `SQLAnywhere2::Result` includes `Enumerable` you can easily go through all the results like so:

```ruby
# Each row is an array of column results
results.each { |row| puts row }
```

You can get all column info returned by query.
Result row element indexes all correspond to the column with the same index.

```ruby
results.columns
```

## Result types

By default most sql types are casted to their respective ruby type.
Some of those casts might be uneeded.
This can be disabled by passing `:cast` option when making a connection

```ruby
SQLAnywhere2::Connection.new conn_string: "", cast: false
```

### Time/Timestamp timezones

When creating `Time` objects from sql data values you can set which timezone to use using `:database_timezone` option.
Currently only `:local` and `:utc` are supported.
By default SQLAnywhere2 uses `:local` option.

### Bit

All bit values are casted to ruby `TrueClass`/`FalseClass`.

## libdbcapi VM crash

The following example illustrates the problem with libdbcapi

```SQL
create or replace procedure test(@param int)
begin
    select newid() as a
end
```

```ruby
connection = SQLAnywhere2::Connection.new conn_string: "ServerName=MyServer;DatabaseName=MyDatabase;U
serID=root;Password=pwd;CommLinks=tcpip(host=MyHost);CharSet=UTF-8;"

connection.execute_direct("call test()")
```

After executing this code most times ruby VM crashes.
This can be fixed by sending a SET query with procedure call like so

```ruby
connection = SQLAnywhere2::Connection.new conn_string: "ServerName=MyServer;DatabaseName=MyDatabase;U
serID=root;Password=pwd;CommLinks=tcpip(host=MyHost);CharSet=UTF-8;"

connection.execute_immediate('CREATE VARIABLE @@sqlawnywhere2_fix char(1)') if @enable_crash_fix
connection.execute_direct("set @@sqlanywhere2_fix = ''; call test()")
```

Such functionality can be enabled by passing `:enable_crash_fix` option.

## Version support

This gem is tested using SQLAnywhere 16.
Unfotunately it is impossible to test versions below.
In theory it should support all SQLAnywhere versions as long as they support SQLANY_API_VERSION_2.
That means all SQLAnywhere versions up from 12 should work.

All Linux and MacOS Ruby MRI versions from 2.3 are supported.
This is not tested on Windows.

## Development

Use 'bundle install' to install the necessary development and testing gems:

```bash
bundle install
```

After which you can use `rake` command to run rspec tests and rubocop linting


text:
# MM-Unicoder

## What is this?

Just a small library to convert given character or string into Myanmar Unicode. You can use this to let the user input Myanmar Unicode characters without them having the keyboard. :wink:

## How to use this?

Just insert `mm-unicoder.js` into your html file like this.

```html
<script type="text/javascript" src="mm-unicoder.js"></script>
```

And you can start using.

```javascript
// convert just one characters
var result = mmUnicoder.convertChar('a')

// conver one whole string
var output = mmUnicoder.convertString('csD;xkwf')
```

## Examples

- [codepen.io](https://codepen.io/shine_htetaung/pen/OjOLgX)

## Credits

- [Phyo Thet Zaw](https://github.com/phyotz) for helping me with unicode stuffs :tada:

repository: ha-shine/mm-unicoder

repo_name: ha-shine/mm-unicoder


text:
# sprinkler

DoS prevention mechanisms designed for distributed systems:
* distributed agent threads working in an asynchronous or a realtime synchronous pattern
* master threads to gather ONLY important events of anomaly, potentially also provide some backtracing capability
* clusterwide thread id

The **agent threads**, at a remote location, will independently detect system anomalies and intervene while notifying master threads.
All threads (including master threads) work independently of each other, so that there will not be a single point of failure.

The anomaly detection is typically formulated as a *finite state machine* that tracks the operational activities of the system.
Then intervene as necessary based on the *anomaly state transitions* that occur in the local system.
A notification may be send to master threads through an encrypted channel, possibly containing identifying information to facilitate backtracing.
Therefore, a proper communication over TLS is enforced.

> Note: to make distribution of configuration and certificates easier, most information is baked into the binary executable at compilation, private key encrypted, which is to be done on a master node (that has all the configs, certs, keys and toolchain ready).

The **master threads**, gathered at a single reachable networking endpoint, may participate in DoS prevention from a control plane angle or only record system anomalies.
They do not have control over agent threads or send anything back (which otherwise may open up more security loopholes).

> Note: to simplify firewall configurations, only the master node listens

repository: aleozlx/sprinkler

repo_name: aleozlx/sprinkler


text:
# SomeWebClicker
![status](https://img.shields.io/badge/status-complete-brightgreen.svg)
![maintained](https://img.shields.io/badge/maintained-no%20(as%20of%202018)-red.svg)

[![GitHub issues](https://img.shields.io/github/issues/hparcells/SomeWebClicker.svg)](https://github.com/hparcells/SomeWebClicker)
[![GitHub pull requests](https://img.shields.io/github/issues-pr/hparcells/SomeWebClicker.svg)](https://github.com/hparcells/SomeWebClicker)
[![GitHub](https://img.shields.io/github/license/hparcells/SomeWebClicker.svg)](https://github.com/hparcells/SomeWebClicker)

The Code to My Web Clicker Game

A lot of the code is badly designed, and probably will be all revised in the near future.

## Play
You can play Some Web Clicker now at https://some-web-clicker.netlify.com/.

## Completed Project
The completed status of this project means I will not be actively developing this, other than small bug fixes, and responding to pull requests and issues represented by the maintained badge. You can feel free to open a pull request with new features if you choose to do so.

repository: hparcells/some-web-clicker

gha_language: JavaScript

repo_name: hparcells/some-web-clicker


text:
#### A great looking and easy-to-use photo-management-system.

*Since the 1st of April 2018 this project has moved to it's own Organisation (https://github.com/LycheeOrg) where people are able to submit their fixes to it. We, the Organisation owners, want to thank electerious (Tobias Reich) for the opportunity to make this project live on.*

![Lychee](https://camo.githubusercontent.com/b9010f02c634219795950e034f511f4cf4af5c60/68747470733a2f2f732e656c6563746572696f75732e636f6d2f696d616765732f6c79636865652f312e6a706567)
![Lychee](https://camo.githubusercontent.com/5484591f0b15b6ba27d4845b292cc5d3a988b3b9/68747470733a2f2f732e656c6563746572696f75732e636f6d2f696d616765732f6c79636865652f322e6a706567)

Lychee is a free photo-management tool, which runs on your server or web-space. Installing is a matter of seconds. Upload, manage and share photos like from a native application. Lychee comes with everything you need and all your photos are stored securely. Read more on our [Website](https://LycheeOrg.github.io).

## Installation

To run Lychee, everything you need is a web-server with PHP 7.1 or later and a MySQL-Database. Follow the instructions to install Lychee on your server. This version of Lychee is built on the Laravel framework. To install:

1. Clone this repo to your server and set the web root to `lychee-laravel/public`
2. Run `composer install --no-dev` to install dependencies
3. Copy `.env.example` as `.env` and edit it to match your parameters
4. Generate your secret key with `php artisan key:generate`
5. Migrate your database with `php artisan migrate` to create a new database or migrate an existing Lychee installation to the new framework.

See detailed instructions on the [Installation](https://github.com/LycheeOrg/Lychee-Laravel/wiki/Install) wiki page.

### Update

Updating is as easy as it should be.  [Update »](https://github.com/LycheeOrg/Lychee/wiki/Update)

### Build

Lychee is ready to use, right out of the box. If you want to contribute and edit CSS or JS files, you need to rebuild Lychee. [Build »](https://github.com/LycheeOrg/Lychee/wiki/Build)

### Keyboard Shortcuts

These shortcuts will help you to use Lychee even faster. [Keyboard Shortcuts »](https://github.com/LycheeOrg/Lychee/wiki/Keyboard%20Shortcuts)

### Dropbox import

In order to use the Dropbox import from your server, you need a valid drop-ins app key from [their website](https://www.dropbox.com/developers/apps/create). Lychee will ask you for this key, the first time you try to use the import. Want to change your code? Take a look at [the settings](https://github.com/LycheeOrg/Lychee/wiki/Settings) of Lychee.

### Twitter Cards

Lychee supports [Twitter Cards](https://dev.twitter.com/docs/cards) and [Open Graph](http://opengraphprotocol.org) for shared images ([not albums](https://github.com/electerious/Lychee/issues/384)). In order to use Twitter Cards you need to request an approval for your domain. Simply share an image with Lychee, copy its link and paste it in [Twitters Card Validator](https://dev.twitter.com/docs/cards/validation/validator).

### Imagick

Lychee uses [Imagick](https://www.imagemagick.org) when installed on your server. In this case you will benefit from a faster processing of your uploads, better looking thumbnails and intermediate sized images for small screen devices. You can disable the usage of [Imagick](https://www.imagemagick.org) in [the settings](https://github.com/LycheeOrg/Lychee/wiki/Settings).

## Troubleshooting

Take a look at the [WIKI](https://github.com/LycheeOrg/Lychee-Laravel/wiki/) and the old Lychee [FAQ](https://github.com/LycheeOrg/Lychee/wiki/FAQ) if you have problems. Discovered a bug? Please create an issue here on GitHub!

repository: tmp-hallenser/Lychee-Laravel

gha_language: PHP

repo_name: tmp-hallenser/Lychee-Laravel


text:
# Bank-Managment-System
bank management system is an application for maintaining a person`s account in the bank
Create account as a customer  :
selecting this creates a new account as a customer by accepting input such as Name , address ,Balance , Pin number , Home phone , Work phone

Show Account information :
To display the data customer to the user

Search Account :
Enables to search for the details of the given social security , display only one account detail at time .

Deposit :
 provide options to deposit amount from the given account number
withdraw :
provides options to withdraw amount from the given social security number .
Delete account :
Cancels the selected account from the bank by Employee

Create Account as Employee :
selecting this creates a new account as a customer by accepting input such as Name , address , Total grade , college , department
Show account :
To display the data of the employee  to the user
Erase  account :
To Delete account of employee from the bank system

repository: osamaalaa/Bank-Managment-System

repo_name: osamaalaa/Bank-Managment-System


text:
#HangZhou Metro
HangZhou Metro is a application based on a  real-world automated fare collection (AFC) dataset of Hangzhou metro system downloaded from Tianchi Competition.The application aims to gain a better understanding of the underlying passenger flow patterns in cities with overcrowding in metro systems.

#Basic Function
Data Filter can load data selectively.
Traffic Trend can plot inflow,outflow and total flow trend of a specific station in a specific time period.
Routes Recommendation can give feasible path suggestions to users  includin options of "Shortest Route","Least Crowded Route","Recommended Route" and "All Routes".

#Elective Analysis
Please check the REPORT.pdf

#Environment Requirements
Device type:Desktop
Compiler:MinGW 5.3.0 32bit for C++
Debugger:Qt\Qt5.11\Tools\mingw530_32\bin\gdb.exe
CMake:Unconfigured
CMake Configuration:
CMAKECXXCOMPILER:STRING=£•
{Compiler:Executable:Cxx}
CMAKECCOMPILER:STRING°™%{Compiler:Executable:C}
CMAKEPREFIXPATH:STRlNG=%{Qt:QTINSTALLPREFIX}
QTQMAKEEXECUTABLE:STRING=%{Qt:qmakeExecutable}

###PLEASE REFER TO ENVIRONMENT.PNG###

#Instructions to Run The Codes
CHANGE THE ABSOLUTE PATH in mythread.cpp line 11 and 16 to your local dataset storage path.£®dataset£©
CHANGE THE ABSOLUTE PATH in mainwindow.cpp line 232 to your local Metro_roadMap csv file storage path.£®metro map£©

#Support
Please contact me by email<EMAIL_ADDRESS>if there's any question running the project.

#License
MIT License

Copyright (c) 2019 Peiyu Chen

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.

src_encoding: MacCentralEurope


text:
---
layout: default
---

# 1996-07-16 - Re: brokers as middlemen

## Header Data

From: snow<EMAIL_ADDRESS>To: "Timothy C. May"<EMAIL_ADDRESS>Message Hash: b55195ce10546de02c4cc785c22087aa647ff262157db3f505a09476765b4ad9

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-07-16 15:11:59 UTC

Raw Date: Tue, 16 Jul 1996 23:11:59 +0800

## Raw message

```
{% raw  %}From: snow<EMAIL_ADDRESS>Date: Tue, 16 Jul 1996 23:11:59 +0800
To: "Timothy C. May"<EMAIL_ADDRESS>Subject: Re: brokers as middlemen
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Mon, 15 Jul 1996, Timothy C. May wrote:
> At 5:48 PM 7/15/96, L. Detweiler wrote:
> >that could be regarded as the ultimate capitalist market-- something
> >that eliminates all "unnecessary" middlemen. I suspect the stock exchanges
> >of the future will *not* be regulated because they *cannot* be. it
> >will be a matter of buyers and sellers choosing the systems that
> >best suit them regardless of what governments feel is appropriate, fair,
> >or whatever.
> I emphatically agree! There is little need for regulation in this new
> environment, and "reputations matter." And regulation is becoming
> problematic.
> (To cite one example. Some are calling for registration and regulation of
> "investment advice," which is largely unregulated in the U.S. today. That
> is, I can self-publish a newsletter, "Tim's Stock Picks," and the First
> Amendment says this can't be restricted (Caveat: But I can't sell "Tim's
> Legal Advice," "Tim's Earthquake Safety Advice," or "Tim's Medical Advice"
> to clients...go figure). Some want investment newsletter writers "held

     While IANAL, and I don't know for sure about "Tim's Legal Advice",
there is NOLO press, I don't think they are lawyers. I don't understand
why you couldn't print "Tim's Earthquake Saftey Advice" as long as the
advice wasn't totally erroneous. As to the last, you most certainly _can_
publish "Tim's Health Advise, or Tim's Homeopathic Newsletter and give
essentially medical advise.

     The non-crypto snake oil business is a big as ever in the US.

Petro, Christopher C.
<EMAIL_ADDRESS><prefered for any non-list stuff>
<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [July 1996](/archive/1996/07)

+ Return to "[snow <snow@smoke.suba.com>](/authors/snow_snow_at_smoke_suba_com_)"
+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_got_net_timothy_c_may_)"

+ 1996-07-16 (Tue, 16 Jul 1996 10:25:40 +0800) - [Re: brokers as middlemen](/archive/1996/07/6a1bca8f05b42b7ad2e48cb25930505f89f50121629bb1c6fca599eb4306c7ff) -<EMAIL_ADDRESS>(Timothy C. May)_
  + 1996-07-16 (Tue, 16 Jul 1996 23:11:59 +0800) - Re: brokers as middlemen - _snow<EMAIL_ADDRESS>


text:
# wikitree-x-chrome

Chrome Extension for WikiTree that enables importing data from other trees.

### Publish An Update

1. Update the version in `manifest.json`.
2. Zip the entire wikitree-x-chrome folder.
3. Upload the zip to the [Chrome Web Store Developer Dashboard](https://chrome.google.com/webstore/developer/dashboard).

### Update Genscrape

Download the latest packaged version from unpkg at<EMAIL_ADDRESS>and save it in the includes folder. Then commit and publish an update.

repository: york-solutions/wikitree-x-chrome

repo_name: york-solutions/wikitree-x-chrome


text:
# Flutter-Bluetooth-Chat

**⚠ Disclaimer:** The project is still not stable, it needs more work.

A chat app between Arduino and your phone using Bluetooth.

## Flutter null safety error

Use this command to avoid `null errors`:

`flutter run --no-sound-null-safety`

repository: Youngermaster/Flutter-Bluetooth-Chat

repo_name: Youngermaster/Flutter-Bluetooth-Chat


text:
# Seq Apps

Apps for the [Seq](http://getseq.net) event server. You can find installable versions of these by searching for the [seq-app tag on NuGet](https://www.nuget.org/packages?q=seq-app).

**Important note:** Requires Seq 3.3 or later.

Currently in this repository you'll find:

* **Atlassian Jira** - Create issues on Jira from log events. [NuGet Package](https://www.nuget.org/packages/Seq.App.Atlassian.Jira)
* **Rocket.Chat** - Post log events to Rocket.Chat channel. [NuGet Package](https://www.nuget.org/packages/Seq.App.Rocket)
* **Udp Cast** - Cast events to Udp clients. [NuGet Package](https://www.nuget.org/packages/Seq.App.UdpCast)
* **GitLab Issues** - Create issues on GitLab from Seq events. [NuGet Package](https://www.nuget.org/packages/Seq.App.GitLab)
* **GitHub Issues** - Create issues on GitHub from Seq events. [NuGet Package](https://www.nuget.org/packages/Seq.App.GitHub)

## Authors
* Ali Özgür [@aliozgur](https://twitter.com/aliozgur)

## Seq.App.Jira Screnshot

![Seq.App.Jira](https://github.com/aliozgur/SeqApps/blob/master/assets/ss_jira.png)

## Seq.App.Rocket Screnshot

![Seq.App.Jira](https://github.com/aliozgur/SeqApps/blob/master/assets/ss_rocket.png)

## Seq.App.UdpCast Screenshot
![Seq.App.Jira](https://github.com/aliozgur/SeqApps/blob/master/assets/ss_udp.png)

## Seq.App.GitLab Screenshot
![Seq.App.Jira](https://github.com/aliozgur/SeqApps/blob/master/assets/ss_gitlab.png)

## Seq.App.GitHub Screenshot
![Seq.App.Jira](https://github.com/aliozgur/SeqApps/blob/master/assets/ss_github.png)

repository: aliozgur/SeqApps

gha_language: C#

repo_name: aliozgur/SeqApps


text:
# LMS mBank parser

The parser recognizes and identifies transfer based on following schemats in CSV:
1) invoice number
2) customer's personal data
3) customer's ID

or you have posibility to manually bind transfers to a customer.

## Installation

1. Create folder `backups/import` and add correct permissions.
2. Copy two files from `modules`.
3. Add to `lib/menu.php` following lines in array `finances`.

```php
array(
    'name' => trans('Import mBank'),
    'link' => '?m=cashimportmbank',
    'tip' => trans('Import cash operations from mBank'),
    'prio' => 115,
),
```

When will you finish the installation process, you will see updated menu with a new option **Import mBank**, under Finances tab in you LMS.

## Usage
Usage is really simple:
1. Import mBank CSV file.
2. The parser will take a. action
3. Verify found transfer and manually add unrecognized lines to a customer.
4. Import it!

## Contributing
1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3.  Push to the branch: `git push origin my-new-feature`
5. Submit a pull request!

## History
Information about all changes are written in [CHANGELOG.md](CHANGELOG.md).

## License
Information about license is under [LICENSE](LICENSE).

repository: iDevOps-pl/lms-parser-mbank

repo_name: iDevOps-pl/lms-parser-mbank


text:
# Unity (0.6.0)
Being productive made easy | Start your favorite programs, playlists, and productivity setups at the touch of a button

## Notes
Version 0.6.0
This project is not yet ready for use in production.
The main features of Unity work, just add your own scripts (including the correct paths) and you're good to go.

The first public release (v 1.0) will be ready before the end of 2017.

repository: yaroschiffelers/Unity

repo_name: yaroschiffelers/Unity


text:
# toy-robot-simulator

[![Build Status](https://travis-ci.com/harsilspatel/toy-robot-simulator.svg?token=yLgWGY7CNm621frWpHzZ&branch=master)](https://travis-ci.com/harsilspatel/toy-robot-simulator)

> A library that allows for a simulation of a toy robot moving on a 5 x 5 square tabletop.

#### Please visit the GitHub [repo](https://github.com/harsilspatel/toy-robot-simulator/) for the best experience.

## Development
### Testing
This project uses pytest for testing.
Visit https://docs.pytest.org/en/latest/ to know more.

### Continuous Integration
Travis CI is employed to test the software updates. Please visit https://about.travis-ci.com/ for more information.

## Usage
1. Clone the repo.
2. Run `pip3 install requirements.txt` to install dependencies.
3. `chmod +x main.py` for execution permissions. (Or can be called using python3).
4. `./main.py {arguments}`

### CLI Arguments
`filename`</br> the file contatining robot commands. This argument can be omitted should the user wishes to enter commands from the CLI.

### Executing the tests
`pytest test.py --capture=fd` </br>
We run the pytest with the capture flag so as to capture and test the REPORT commands' outputs. </br>

The code is tested against:
1. Provided tests and expected outputs (testing only the output).
2. Hard-coded tests containing erroneous command arguments (testing only the output).
3. Automatically generated tests that check robot's attributes after executing each command. (testing position, direction and output).

repository: harsilspatel/toy-robot-simulator

repo_name: harsilspatel/toy-robot-simulator


text:
---
title: "131 - Object"
menu:
  main:
    name: "Object"
    identifier: "technical/types/object"
    parent: "technical/types"
---
# Object

An object represents an instance of a certain objecttype, which is defined in the user [schema](/en/technical/types/schema).
Objects have a set of common properties, which are independent of the objecttype definition.

## Attributes

| Name                        | Description                                                                                | Search        |
|-----------------------------|-----------------------------------------------------------------------------------------------------------|---------------|
| `_format`                   | Format of this record (string, r): **full**, **long**, **standard** or **short** (see below)              |               |
| `_schema_version`           | User schema version this object was generated with (integer, r)                                           |               |
| `_objecttype`               | Name of the objecttype (string, r): ref [table-definition](/en/technical/types/schema).name       | NotAnalyzed   |
| `_system_object_id`         | System object ID (string, unique ID for this easydb instance, r)                                          | Number        |
| `_global_object_id`         | Global object ID (string, unique ID for all easydb instances, r): see below                               | NotAnalyzed   |
| `_uuid`                     | Universal Unique ID (string, unique ID for all easydb instances, r)                                       | NotAnalyzed   |
| `_acl`                      | ACL (array of [acl entries](/en/technical/types/acl_entry), rw, optional) (\*)                          |               |
| `_has_acl`                  | Whether this object has a non-empty ACL (boolean, r)                                                      | Boolean       |
| `_private_acl`              | Marks the ACL as private (see [rights management](/en/technical/rightsmanagement)) (bool, rw, optional): defaults to **false** |  |
| `_tags`                     | Tags (array of [tags](/en/technical/types/tag), rw, optional\*): only `_id` is rendered; `_id` is searchable      | Number        |
| `_collections`              | Collections this object is in (array of objects with `_id`), r): `_id` is searchable                      | Number        |
| `_has_children`             | Whether this object has children (boolean, r): only for hierarchical objects                              | Boolean       |
| `_level`                    | Depth of this object in the hierarchy (integer, r): only for hierarchical objects                         | Number        |
| `_path`                     | Hierarchy path, starting from the root (array of objects, r): only for hierarchical objects               | (\*)          |
| `_standard`                 | Information for standard rendering (standard object, r): see below                                        |               |
| `_mask`                     | Mask the object was rendered with (string, rw\*): ref [mask](/en/technical/maskmanagement).name                       | NotAnalyzed   |
| `_comment`                  | Comment to be saved in changelog (string, w)                                                              |               |
| `_owner`                    | Owner ([group (short)](/en/technical/types/group) or [user (short)](/en/technical/types/user), rw): see below  |    |
| `_changelog`                | History of changes performed on this object (array of [changelog entries](/en/technical/types/cl_entry), sorted by `version`) |   |
| `_generated_rights`         | Rights that this user has for the object ([rights specification](/en/technical/types/right)): see below | |
| `_current_version`          | Whether this object is in the current version (bool, r)                                                   | Boolean       |
| `_last_modified`            | Last modified date in UTC (string, r)                                                                     | Timestamp     |
| `_published`                | List of [publishing information objects](/en/technical/types/publish) (array, r)                          |               |
| ↦ `_id`               | ID of publishing information object (integer, r)                                                          |               |
| ↦ `version`           | Version requested to publish                                                                              |               |
| ↦ `timestamp_created` | Date and time of publishing (string, r)                                                                   | Timestamp     |
| ↦ `collector`         | Name of collector (string, r)                                                                             | String        |
| ↦ `publish_uri`       | External URI where the object is published (string, r)                                                    | String        |
| ↦ `easydb_uri`        | easydb URI used for publishing (string, r)                                                                | String        |
| `_published_count`          | Number of publishing information objects                                                                  | Integer       |
| `<object-type-name>`        | Object attributes (the attribute name is the value of `_objecttype`): see below                           |               |

(\*) Remarks:

- `_acl` and `_private_acl` only exists if the objecttype [table definition](/en/technical/types/schema) has the `acl_table` flag.
- `_tags` only exists if the objecttype [table definition](/en/technical/types/schema) has the `has_tags` flag.
  - to add a tag to an object, it is possible to lookup the tag id using the `reference` field of the tag. See [Lookups for Tag ID](/en/technical/datamanagement/lookups/#example-lookup-for-tag-id).
- `_path.<object-type-name>._id` is searchable as Number.
- `_path._global_object_id` is searchable as NotAnalyzed.

The following fields can be used when searching:

| Name                        | Description                                                                                | Search        |
|-----------------------------|-----------------------------------------------------------------------------------------------------------|---------------|
| `_changelog`                |                                                                                |               |
| ↦ `date_created`      | Creation date of the user object                                                                          | Timestamp     |
| ↦ `date_last_updated` | Date of last update                                                                                | Timestamp     |
| ↦ `user_created`      | User that created the object                                                                              | Number        |
| ↦ `user_last_updated` | User that updated the object the last time                                                                | Number        |
| ↦ `comment`           | Comment that was provided for an insert/update                                                            | Text          |

### Generated rights

The `_generated_rights` are the rights that the user has for a particular object. They allow to build the possible actions into the client.
The following is a list of all possible rights:

- `write`: the user can modify this object
- `delete`: the user can delete this object
- `acl`: the user can modify this object's ACL
- `change_owner`: the user can transfer ownership of this object
- `unlink`: the user can change the pool of this object (provided they have a `link` right for the target pool)

The `_generated_rights` are always provided by [/api/db](/en/technical/api/db).
[/api/search](/en/technical/api/search) provides them on demand (attribute `generate_rights`).

### Format

Objects can be rendered in three different formats. The **full** format contains all fields, as described here.

The **short** format contains:

- `_format`
- `_mask`
- `_objecttype`
- `_system_object_id`
- `_global_object_id`
- `_uuid`
- `<objecttype>._id`
- `<objecttype>._version`
- `_has_children` (only for hierarchical objects)
- `<objecttype>._id_parent` (only for hierarchical objects)
- `_tags`
- `_last_modified`

The **standard** format contains the same fields as **short** plus:

- `_standard`
- `_path` (only for hierarchical objects)
- `_pool` (only for objects with pool link and visible pool)

The **long** format contains all fields, except:

- `_changelog`

> Attention: the following feature is **only available in [fylr](http://fylr.io/)**

The **standard_extended** format is a new format that provides the data of fields in an object in a fixed structure. It can be displayed by using a generic parser without any knowledge about the database schema.

For a detailled documentation on this format, see [Object Format standard_extended](standard_extended)

### Global object ID

The global object ID is composed of a system ID and an instance name (`"<system_object_id>@<instance_name>"`). It allows to identify an object
uniquely across all Easydb instances. When performing a search, the instance name can be replaced by the alias `"local"`, but the response will always
contain the instance name.

### Owner

An object alway has a valid owner. On object creation, the server initializes this field to the user creating the object, but it won't complain if the
API call sets the same value. If the user attempts to set a different owner, the error [403 Change Owner On Creation](/en/technical/errors)
is returned. When updating an object, the owner has to be provided, and it cannot be set to **null**.

The owner of an object has the following rights:

- `read`, `write`, `delete`
- `acl`

### Standard object

The standard object is rendered according to the mask. It contains up to 3 levels of textual representation (text and HTML) plus up to 2 levels of
assets. The number of actual levels depends on the mask. The keys `<level>` are strings that contain the level number ("1", "2", "3").

| Name                        | Description                                                                                | Search        |
|-----------------------------|-----------------------------------------------------------------------------------------------------------|---------------|
| `<level>`                   | Level of textual representation (can be interpreted as title, subtitle and description, for example)      |               |
| ↦ `text`              | - as plain text ([l10n](/en/technical/types/l10n))                                                                | L10n          |
| ↦ `html`              | - as HTML ([l10n](/en/technical/types/l10n))                                                                      |               |
| `eas`                       | Standard assets                                                                                |               |
| ↦ `<level>`           | Level of asset representation (can be interpreted as main and detailed, for example)                      |               |
|                             | The asset record has a subset of the attributes of an asset (see [asset](/en/technical/types/asset)):             |               |
| ↦ ↦ `_id`                    | | |
| ↦ ↦ `class`                  | | |
| ↦ ↦ `extension`              | | |
| ↦ ↦ `class_extension`        | | |
| ↦ ↦ `compiled`               | | |
| ↦ ↦ `technical_metadata`     | | |
| ↦ ↦ `filesize`               | | |
| ↦ ↦ `original_filename`      | | |
| ↦ ↦ `versions`               | | |
| ↦ ↦ ↦ `small`          | | |
| ↦ ↦ ↦ ↦ `status` | | |
| ↦ ↦ ↦ ↦ `url`    | | |
| ↦ ↦ ↦ ↦ `width`  | | |
| ↦ ↦ ↦ ↦ `height` | | |
| ↦ ↦ ↦ `preview`        | | |
| ↦ ↦ ↦ ↦ `status` | | |
| ↦ ↦ ↦ ↦ `url`    | | |
| ↦ ↦ ↦ ↦ `width`  | | |
| ↦ ↦ ↦ ↦ `height` | | |

### Object attributes

There are some common attributes, which begin with "\_" and user-defined attributes.
The latter depend on the mask used for rendering (`_mask`). All are located under `<object-type-name>`:

| Name                        | Description                                                                                | Search        |
|-----------------------------|-----------------------------------------------------------------------------------------------------------|---------------|
| `_id`                       | Object ID (integer, r, unique for a given object type)                                                    |               |
| `lookup:_id`                | Lookup for ID of a linked object, [see below](#lookup-for-id-of-linked-object)                            |               |
| `_version`                  | Object version (integer, rw)                                                                              | Number        |
| `_id_parent`                | Parent object ID (integer, rw, optional): ID of the parent (only for hierarchical objects)                | Number        |
| `lookup:_id_parent`         | Lookup for ID of parent object, [see below](#lookup-for-id-of-parent-object)                              |               |
| `_pool`                     | Pool this object is in ([pool (short)](/en/technical/types/pool), rw\*): only for objects with pool link  | Number (\*)   |
| `<field_name>`              | Value of the field `field_name`, the format depends on the field type (see comments below)                | (see below)   |

#### Pool:

When the attribute `pool_link` is set for the objecttype (see [Schema](/en/technical/types/schema)), the `_pool` field is used to
get/set the pool this object is in. When updating an object's pool, only `_pool.pool._id` is set, but the record is returned
as a complete pool record. The fields `_pool._id` and `_pool._path.pool._id` are searchable as Number.

##### Lookup for Pool ID:

To assign a pool to an object, it is possible to lookup the pool id using the `reference` field of the pool. See [Lookups for Pool ID](/en/technical/datamanagement/lookups/#example-lookup-for-pool-id).

#### Lookup for ID of linked object:

Perform a lookup for the ID of a linked object in the current table.

See [detailled information about lookups](/en/technical/datamanagement/lookups/#example-lookup-for-id-of-linked-objects).

#### Parent ID:

When the attribute `is_hierarchical` is set for the objecttype (see [Schema](/en/technical/types/schema)), the `_id_parent` field is used to
get/set the parent of this object. For top-level objects, set this field to null or do not set it.

#### Lookup for ID of parent object:

Perform a lookup for the parent ID of a object in the current table. This is used to add the parent-child-relation to a hierarchical user object.

See [detailled information about lookups](/en/technical/datamanagement/lookups/#example-lookup-for-parent-id-of-hierarchical-objects).

### Fields

The value of the fields depend on the `kind` and `type` defined for them (see [Schema](/en/technical/types/schema)):

**Kind "column":**

Regular columns have a `field_name` equal to the column name.

| Field type        | Value type (JSON)                        | Search  |
|-------------------|------------------------------------------|---------|
| integer           | integer                                  | Number  |
| serial            | integer                                  | Number  |
| decimal.2         | decimal                                  | Number  |
| boolean           | boolean                                  | Boolean |
| text              | string                                   | Text    |
| text_oneline      | string                                   | Text    |
| text_l10n         | [L10n](/en/technical/types/l10n)                 | L10n    |
| text_l10n_oneline | [L10n](/en/technical/types/l10n)                 | L10n    |
| string            | string                                   | String  |
| date              | [Date](/en/technical/types/date)            | Date    |
| date_range        | [Date Range](/en/technical/types/date) | Date    |
| date_time         | [Date](/en/technical/types/date)            | Date    |
| eas               | array of [assets](/en/technical/types/asset), one for each version | Nested (\*) |
| link              | [Object](/en/technical/types/object) in **standard** format |         |
| custom            | JSON object, as defined by the Custom Data Type plug-in | Custom |

Notice that the column "Search" specifies the indexing type for the field, but a specific field can be not
searchable for a certain user because of the mask.

Whether the field can be searched in "all" or not depends on the configuration of the mask (option "fulltext").

(\*) see [Asset](/en/technical/types/asset) to find out which fields are indexed and how

**Kind "link":**

Links have the following `field_name`:

- `_nested:<table-name>` for a regular linked table
- `_reverse_nested:<table-name>` for a reverse linked table

The value is an array of objects. The composition of the objects depends on the linked mask and follows the
rules of "Fields".

## Related operations

- [/db](/en/technical/api/db): CRUD operations on objects
- [/search](/en/technical/api/search): Search type "objects"

repository: programmfabrik/easydb-documentation

gha_language: Go

repo_name: programmfabrik/easydb-documentation


text:
## About
"I have no idea how to write game engines"-style game engine. A playground for my gamedev experiments.

![1](/screenshots/screenshot13.png?raw=true)

## Features
- [Unity](https://unity.com)-inspired component system.
- Loading of several popular mesh and texture formats, also TTF fonts.
- [Bullet](https://github.com/bulletphysics/bullet3) physics.
- Vulkan/OpenGL 4 rendering backend.
- Same API for both Lua and C++.
- [Dear ImGui](https://github.com/ocornut/imgui) UI.

## Building
- Install dependencies:
  - Python2 (Python3 might work, but not tested). Needed for building some engine dependencies.
  - Vulkan SDK.
- `cd build`.
- `cmake -G "Visual Studio 16 2019" -A x64 ..` (or other generator depending on the OS/IDE).
- Build the generated project.

## Running Lua demos

Using scripts
- `cd build`
- `run-lua-demo1-debug-gl.cmd` or other similar script.

or manually
- `cd build/bin/<Debug|Release>`
- `Solr.exe ../../../src/demos/lua/demo<N>/demo_<gl|vk>.lua` where `N` is the demo number

license: Zlib

gha_license_id: Zlib


text:
---
layout: post
category: new
title: "Tavernacular"
description: "n. Speech unintelligible by all but the most devout local tavern patrons. | n. A prayer ... muttered cryptically in local tongue while (cont'd...)"
tags: [ local, dialect ]
---

***n.*** Speech unintelligible to all but the most devout local tavern patrons.

***n.*** A prayer or profanity muttered cryptically in local tongue while blowing into a breathalyzer.

also ***n.,* Tavernacle**, A pub of local worship.

repository: outrightmental/etymolution

gha_language: HTML

repo_name: outrightmental/etymolution


text:
---
layout: page
title: About
permalink: /about/
---

My name is Jason Haas, and I'm a developer.  My background is electrical and system engineering, but I've transitioned over to pure software development (with the usual linux hacking work mixed in) over the last few years.  The reason I made the switch is worth a blog post in itself, which I will write at some point.

I love technology and **simple** and **intuitive** tools.  I love all tech, but my primary interest these days is Python, Git, large scale data processing, and web development.  I'm a believe in the K.I.S.S principal and UNIX design paradigms.  Each application or piece of code should do one thing, and do it really well.

## This blog

This blog is meant to share some tips & tricks I learn along the way, trying to provide unique perspectives where I can.

## Contact

- [LinkedIn](https://linkedin.com/in/jasonrhaas)
- [Github](http://github.com/jasonrhaas)
- [Twitter](http://twitter.com/jasonrhaas)


text:
---
layout: default
---

# 1995-11-15 - Re: the revolution of microcurrency

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 277f130195d0006b026e8dbe2cb663f1c57d08d35caec1414aaefdd6d70c1bfa

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-11-15 05:55:55 UTC

Raw Date: Wed, 15 Nov 1995 13:55:55 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Wed, 15 Nov 1995 13:55:55 +0800
To<EMAIL_ADDRESS>Subject: Re: the revolution of microcurrency
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>From Thomas Junker (in reply to Vlad):

> this same idea works with software. you don't see
> software as an end product. you see it as something that
> is evolving over time. and whenever you send money to a
> company for software, in this new system the idea is that
> "I like this software, and I want to see it grow. here
> is my contribution to that".

People as marketplace players do not think like that.
....................................................

This is a very important point to consider:  how a person as a customer will
_actually_ think.

It is easy enough to propose schemes based on one's preferences of how one
would like a potential customer to make decisions about services, products, and
methods of payment for what is offered.  But doing the customer's thinking for
them doesn't automatically transform them into that line of reasoning.

To better compute whether they will proceed according to how you have imagined,
it is more realistic to consider how the other person reasons on the
circumstance they are facing - from their perspective.

Market researchers actually carry out tests for consumer response and
acceptance of products or payment schemes in order to gauge their success.  And
there are many kinds of potential customers, who will make different decisions
in regard of the same thing:  some will find it a good idea to think about
software in terms of "contributing to its growth" in the longterm, but some
will have immediate needs which they are trying to satisfy and may think "I
need a solution to my problem *right now*" and will look for the
product/service which will solve their problem as it stands in the present.

This is another attractive feature of "the free market":  in it one can find
all sorts of schemes & methods for solving all sorts of problems in different
ways.  There is no single type of consumer, no single circumstance, no one
service or product or scheme which will satisfy everyone, equally, at all
times.

"May the Best Man Win", and "To the Victor Belong the Spoils".  <g>

  ..
Blanc

{% endraw %}
```

## Thread

+ Return to [November 1995](/archive/1995/11)

+ Return to "[blancw@accessone.com](/authors/blancw_at_accessone_com)"

+ 1995-11-15 (Wed, 15 Nov 1995 13:55:55 +0800) - Re: the revolution of microcurrency -<EMAIL_ADDRESS>


text:
coverage.el generates code coverage profiles and overlays them in GNU
Emacs buffers.

Adding support for new languages and tools is easy. Currently
coverage.el supports Go coverage profiles, gcov profiles, and lcov
profiles.

![Go coverage profile](go.png)

# Installation

Add to .emacs.el

    (add-to-list 'load-path "/path/to/coverage/directory")
    (require 'coverage)

The package requires GNU Emacs 24.3+.

To test the package after installation

* open coverage-test.el
* Run eval-buffer (M-x eval-buffer RET)
* Run ert (M-x ert RET t RET)

# Usage

Open and follow instructions in files

* examples/go/example.go
* examples/c/example.c

More information is in the Commentary section in the coverage.el file.

# Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md).

# Disclaimer

This is not an official Google product.

repository: tpanum/coverage

repo_name: tpanum/coverage


text:
# Non-Fungible Token FRAME Pallet

This is a [FRAME](https://substrate.dev/docs/en/knowledgebase/runtime/frame) pallet that defines and implements a
[non-fungible token (NFT)](https://en.wikipedia.org/wiki/Non-fungible_token) interface.

## Tests

Refer to the [mock runtime](src/mock.rs) and [provided tests](src/tests.rs) to see the NFT implementation in action.

## Acknowledgements

This project was inspired by works such as the following:

- [The ERC-721 specification](https://eips.ethereum.org/EIPS/eip-721)
- [OpenZeppelin's ERC-721 implementation](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC721)
- [the original Substratekitties project](https://www.shawntabrizi.com/substrate-collectables-workshop/#/), by
  [@shawntabrizi](https://github.com/shawntabrizi/)
- [Substratekitties from SubstrateCourse](https://github.com/SubstrateCourse/substrate-kitties), by [@xlc](https://github.com/xlc/)

Thanks to the following people who helped me overcome my relatively limited understanding of Rust.

- [@JoshOrndoff](https://github.com/JoshOrndorff/)
- [@riusricardo](https://github.com/riusricardo/)
- [@rphmeier](https://github.com/rphmeier/)
- [@thiolliere](https://github.com/thiolliere/)
- [@gnunicorn](https://github.com/gnunicorn/)

## Upstream

This project was forked from
[the Substrate DevHub Pallet Template](https://github.com/substrate-developer-hub/substrate-pallet-template).


text:
# KWallet

> A digital wallet for all your credit card needs

## About
Did you ever have to get your credit card info but you didn't have your wallet near you?
Or you just have lots of credit cards and want them all in one place?

KWallet aims to solve this exact problem (in the future) by keeping an overview of your cards in an app.
Right now this is only my personal playground to get familiar with Jetpack Compose though

---

## Getting started
In theory you should just be able to clone this project, open your favorite IDE and run it. It currently only supports Android so you need to have JAVA installed. I chose most dependencies carefully so multi-platform _should_ be possible with some modifications

---

## So what does it look like?
Awesome! Jokes aside, I only just started this project and focused on functionality more than UI/UX. I do plan on making it better once I have all the basic functionality working though. Whenever it looks actually visibly appealing, you'll get your screenshots, I promise.
Can't tolerate the current "design"? I'm always happy for any contributions!

---

## Current features, aka what's working
Visually, you just have a screen and a card that brings you to a card creation screen

Under the hood, there's already a simple database structure, navigation is working and you can **flip cards**. Dependency injection is also working and everything is a Composable with Preview features. No more XML views

---

## Planned features
These are in the current order I plan to work on them. If you have any other ideas feel free to open an issue
### Current focus
- Think about different ways of presenting the card creation layer. A new screen seems overkill

### Future thoughts
- Set up a GitHub action
- UI overhaul, custom color scheme, material or glassmorph design, animations and transitions
- Add some tests
- Make the whole project more modular
- Add other types of cards, i.e. debit cards, insurance, ID?
- Add payment details screen for each credit card
- Add biometric/password lock so your credit cards are actually secure
- Release it on F-Droid

---

## Can I contribute?
Yes please! Contributions are always welcome. The code is probably a bit messy since this is my first Jetpack Compose project (and Android project in general) so I'd actually love some feedback and suggestions.

---

## License
[MIT](LICENSE.md)

For a full overview of dependencies and their licenses also see [third-party-licenses](/third-party-licenses)

gha_language: Kotlin