text:
# 3D Secure 2

The previous version of 3D Secure (3DS) redirected the cardholder to the bank's website,
3D Secure 2 (3DS2) now provides strong customer authentication allowing the customer to authenticate directly within the merchant application.

## Get Started

To use 3DS2, the `AuthorizingPaymentConfig.initialize(config)` function must be called before starting the authorizing payment process with `authorize_uri` [see more](https://www.omise.co/how-to-implement-3-D-Secure).

```kotlin
  val threeDSConfig = ThreeDSConfig.Builder()
          .uiCustomization(uiCustomization)
          .timeout(5)
          .build()
  val authPaymentConfig = AuthorizingPaymentConfig.Builder()
          .threeDSConfig(threeDSConfig)
          .build()
  AuthorizingPaymentConfig.initialize(authPaymentConfig)
```

These are the available configurations in 3DS2.

| Config | Description |
|---|---|
| `uiCustomization` | Configuration for UI customization in the challenge flow. |
| `timeout` | Maximum timeout for the challenge flow. The acceptable timeout is 5-99 mins. |

To use the authentication page, the Omise SDK provides the `AuthorizingPaymentActivity` for handle the authorizing payment. You can declare the `AuthorizingPaymentActivity` in your `AndroidManifest.xml` file.

```xml
<activity
  android:name="co.omise.android.ui.AuthorizingPaymentActivity"
  android:theme="@style/OmiseTheme" />
```

In your activity, you can use the `startActivityForResult()` function to start the `AuthorizingPaymentActivity` and handle the result.

```kotlin
val intent = Intent(this, AuthorizingPaymentActivity::class.java)
intent.putExtra(AuthorizingPaymentURLVerifier.EXTRA_AUTHORIZED_URLSTRING, AUTHORIZED_URL)
intent.putExtra(AuthorizingPaymentURLVerifier.EXTRA_EXPECTED_RETURN_URLSTRING_PATTERNS, EXPECTED_URL_PATTERNS)
startActivityForResult(intent, AUTHORIZING_PAYMENT_REQUEST_CODE)
```

After the cardholder completes the payment authorization process, the `onActivityResult()` function will be called in which you can handle the payment authorization result.

```kotlin
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
  if (requestCode == AUTHORIZING_PAYMENT_REQUEST_CODE && resultCode == RESULT_OK) {
    val result = data.getParcelableExtra<AuthorizingPaymentResult>(AuthorizingPaymentActivity.EXTRA_AUTHORIZING_PAYMENT_RESULT)
    when (result) {
      is AuthorizingPaymentResult.ThreeDS1Completed -> TODO()
      is AuthorizingPaymentResult.ThreeDS2Completed -> TODO()
      is AuthorizingPaymentResult.Failure -> TODO()
    }
  }
}
```

You can check out the sample implementation in the [CheckoutActivity](../app/src/kotlin/java/co/omise/android/example/CheckoutActivity.kt) class in the sample app.

> #### Note
> To check the charge status after the payment authorization process completes, you can implement the [`Client.observeTokenUntilChargeStatusChanged()`](#observing-charge-status-in-the-token) function to observe changes in the charge status.

## Using UI customization

In the challenge flow, the Omise SDK allows developers to customize UI elements in the challenge flow. To customize UI, you can create an instance of `UiCustomization` and set your preferred properties through the `UiCustomization` class. Finally, set `UiCustomization` instance through `ThreeDSConfig.uiCustomization()` function.

```kotlin
val uiCustomization = UiCustomization.Builder()
          .labelCustomization(LabelCustomization.Builder()
                  .textFontName("RobotoMono-Regular.ttf")
                  .textFontColor("#000000")
                  .textFontSize(16)
                  .build())
  val threeDSConfig = ThreeDSConfig.Builder()
          .uiCustomization(uiCustomization)
          .build()
```

You can check out the [UiCustomization](/sdk/src/main/java/co/omise/android/config/UiCustomization.kt) class to see customizable UI elements in the challenge flow.

## Observing charge status in the token

This is an utility function for observing the token until its charge status changes. You can use this function for checking the charge status after the payment authorization process completes.

```kotlin
val client = Client("pkey_test_1234")
client.observeTokenUntilChargeStatusChanged("tokn_test_1234", object: RequestListener<Token> {
    override fun onRequestSucceed(model: Token) {
        TODO("Not yet implemented")
    }

    override fun onRequestFailed(throwable: Throwable) {
        TODO("Not yet implemented")
    }
})
```

repository: omise/omise-android

gha_language: Kotlin

repo_name: omise/omise-android


text:
---
layout: post
title:  "How Real-Time Collaborative Editors work? [Operational Transformation]"
date:   2017-04-27 90:43:39 -0600
tags: technical javascript js code algorithm kde
---

Recently, I've been diving deep on how **real-time collaborative** editing works. I have been reading various papers on both the methods of implementing collaborative editing : **Operational Transformation**, which goes back to 1989, when it was first implemented by the [GROVE (GRoup Outtie Viewing Editor)](https://www.lri.fr/~mbl/ENS/CSCW/2012/papers/Ellis-SIGMOD89.pdf) system (this algorithm is quite old, and Google uses this algorithm for collaborative editing for Google Docs, Google Slides, Wave, etc) and **Conflict-Free Replicated Data Types**, which is a much newer approach to real-time editing.

### Real challenge of collaborative editing

If you know how real-time collaborative editing works, then you may know that handling concurrent editing in multi user environment gracefully is very challenging. However, a few simple concepts can simplify this problem. The main challenge, as mentioned, with collaborative editing is the concurrency control [**concurrent edits**] to the document are not commutative. This needs to be causally ordered before applying either by undoing history, or by transforming the operations [**operational transformation**] before applying them to make them seem commutative.

### Bringing Latency into action

Introducing latency between the client and server is where the problems arise. Latency in a collaborative editor introduces the possibility of version conflicts. Here, where, I said Operational Transformation will come into action.

Let's take an example :

**Starting Client's state :**

` ABCD `

**Starting Server's state :**

` ABCD `

Now, let's say, *Client* enters `X` in between `C` and `D` , the operation would look something like this :

`insert(X,3) //where 3 is the position where x is going to be added (0=A, 1=B, 2=C ..)`

And at the same time, *Server* deletes `b` , the operation would be :

`delete(B,1)`

What actually should happen is that the client and server should both end with ```ACXD``` but in reality, *client* ends with ```ACXD```

```
Starting Document State -> ABCD
"Insert 'X'" operation at offset 3 [local] -> ABCXD
"Delete 'B'" operation at offset 1 [remote] -> ACXD
```

but the *server* ends with ```ACDX```.

```
Starting Document State -> ABCD
"Delete 'B'" operation at offset 1 [local] -> ACD
"Insert 'X'" operation at offset 3 [remote] -> ACDX
```

Ofcourse, ```ACXD != ACDX``` and the document which is shared now is in wrong state.

Here is where the **Operational Transformation** algorithm comes to the rescue.

### Operational Transformation Algorithm

Operational Transformation (OT) is an algorithm/technique for the transformation of operations such that they can be applied to documents whose states have diverged, bringing them both back to the same state.

#### How does Operational Transformation work?

A short overview of how OT works :

* Every change (insertion or deletion) is represented as an **operation**. An operation can be applied to the current document which results into a new document state.

* To handle concurrent operations, we use the **tranform** function that takes two operations that have been applied to the same document state (but on different clients) and computes a new operation that can be applied after the second operation and that preserves the first operation’s intended change.

Let's apply Operational Transformation in the original example.

If we apply OT, *Client* will see :

```
Starting Document State -> ABCD
"Insert 'X'" operation at offset 3 [local] -> ABCXD
"Delete 'B'" operation at offset 1 [transformed] -> ACXD
```

and *Server* will see :

```
Starting Document State -> ABCD
"Delete 'B'" operation at offset 1 [local] -> ACD
"Insert 'X'" operation at offset 2 [transformed] -> ACXD //Transform function would add add it in the new (3 - 1 = 2) position
```

### Client - Server [OT] Approach to Collaborative Editing

The **transform** function is used to build a client-server protocol that can handle collaboration between any number of clients.

Choosing a Client-Server architecture will allow scouting a large number of clients without actually complicating the environment. Also, there will be a single system which holds the source of truth i.e. the server, so even if the clients crash/go offline for a long time, we can go back to the server and fetch the document easily.

This source of truth also forces the client to wait for the server to **acknowledge** the operation that the client has just sent which would mean that the client always stays on the server's OT path. This would help in keeping a single history of operations without actually having to keep a mirror of the state for each client that is connected. That would eventually mean the number of clients that are connected to the server would have only one single copy of the document on the server.

### Conclusion

**Operational Transformation** is a very powerful tool that allows to build great collaborative apps with support for non-blocking concurrent editing. I am looking forward to dive deep into the algorithm (and ofcourse extending this blogpost) and possibly working on an editor which supports it as well.

### Resources

I've read the following papers and articles to learn about Operational Transformation.

* [High Latency, Low-Bandwidth Windowing in the Jupiter Collaboration System](http://lively-kernel.org/repository/webwerkstatt/projects/Collaboration/paper/Jupiter.pdf) *Authored by David A. Nichols, Pavel Curtis, Michael Dixon, and John Lamping.*

* [Operational Transformation in Real-Time Group Editors: Issues, Algorithms, and Achievements](http://citeseerx.ist.psu.edu/viewdoc/download?doi=<IP_ADDRESS>.933&rep=rep1&type=pdf) *Authored by Chengzheng Sun and Clarence (Skip) Ellis.*

* [Google's whitepaper on Operational Transformation](http://www.waveprotocol.org/whitepapers/operational-transform)

* [Concurrency Control in Groupware Systems](https://www.lri.fr/~mbl/ENS/CSCW/2012/papers/Ellis-SIGMOD89.pdf) *Authored by C.A. Ellis, S.J. Gibbs*

* [Evaluating CRDTs for Real-time Document Editing](https://hal.archives-ouvertes.fr/file/index/docid/629503/filename/doce63-ahmednacer.pdf) *Authored by Mehdi Ahmed-Nacer, Claudia-Lavinia Ignat, G´erald Oster, Hyun-Gul Roh, Pascal Urso*

* [Merging OT and CRDT Algorithms](https://hal.inria.fr/hal-00957167/document) *Authored by Mehdi Ahmed-Nacer, Pascal Urso, Valter Balegas, Nuno Pregui¸ca*

* [Wikipedia on Operational Transformation](https://en.wikipedia.org/wiki/Operational_transformation) *One of the most informative articles, I have found on wikipedia, suprisingly.*

license: MIT

branch_name: refs/heads/master

extension: markdown

license_type: permissive


text:
## MARS Assembler
<img align="right" width="128" height="128" src="https://github.com/PrOF-kk/MM_MARS_Assembler/blob/master/images/RedMars128.png">

[MARS][1] is a lightweight interactive development environment (IDE) for programming in MIPS assembly language, intended for educational-level use

MARS has been jointly developed by [Pete Sanderson][4] (programming) and [Ken Vollmar][5] (details and paperwork).

This is an independent fork maintained by [Valerio Colella][9]. I am not affiliated with the original developers.

## Download
You can download the latest release [here][6]

## Documentation (included in the repo)
 - Go to the [original documentation][7]
 - Go to the [modern documentation (WIP)][10]
 - Please let us know if you find errors or omissions in the documentation
 - In order to run or compile MM MARS, **Java SE 8 (or later) is required**

## MM (More Modern) version notes
 - You can find the complete list of changes and fixes [here](Changelog.md)

## How to run MARS
 - **Option A**: Double-click the .jar file.
 - **Option B**: Open a shell in the same folder as MARS. (Optional) Rename the jar file to "Mars.jar" for convenience. Run MARS with the command  `java -jar Mars.jar`
 - **Option C**: Open a shell in the same folder as MARS. (Optional) Rename the jar file to "Mars.jar" for convenience. Extract MARS files with the command  `jar -xf Mars.jar`. Run MARS with the command `java Mars`

**Linux users:** you might have to run `chmod +x Mars.jar` to set the file as executable

## How to compile
 - **Windows**: execute "CreateMarsJar.bat" file to generate an executable.
 - **GNU/Linux** and **Mac**: execute the "CreateMarsJar.sh" to generate an executable. If you can't due to permissions, execute "**chmod +x CreateMarsJar.sh**" (Thanks to @aesptux for testing the Mac version).

## License
MARS and MM Mars are under the [MIT License][2]. Check the [LICENSE][3] file. Copyright held by the original developers.

  [1]: http://courses.missouristate.edu/KenVollmar/MARS/index.htm
  [2]: https://choosealicense.com/licenses/mit/
  [3]: https://github.com/PrOF-kk/MM_MARS_Assembler/blob/master/LICENSE.txt
  [4]: http://faculty.otterbein.edu/PSanderson/
  [5]: http://courses.missouristate.edu/KenVollmar/
  [6]: https://github.com/PrOF-kk/MM_MARS_Assembler/releases
  [7]: http://courses.missouristate.edu/KenVollmar/MARS/Help/MarsHelpIntro.html
  [9]: https://github.com/PrOF-kk
  [10]: https://prof-kk.github.io/MM_MARS_Assembler/

extension: md


text:
---
slug: /events/DjangoGirls19
name: DjangoGirls
date: 2019-03-24
location: GFloor Seminar Hall
cover: './djangogirls.png'
link: https://djangogirls.org/managaluru
feedback_link: https://forms.gle/BS8sGxXRkFSydpKL8
---

## DjangoGirls
Django Girls is a non-profit organization and a community that empowers and helps women to organize free, one-day programming workshops by providing tools, resources and support.
Django Girls, Mangaluru is an intoductory workshop conducted in collaboration with SOSWC. In this event, attendies
build their first web application using HTML, CSS, Python and Django.
This workshop is for the beginners and hence, you do not need to have any prior programming knowledge.

## Prerequisite
* Laptop
* For installations, follow the instructions: https://github.com/djangogirlsmangaluru/getting-started

## Topics covered
* Learning how the internet works
* Introduction to command line
* Introduction to Python
* Building a small working web application(your own blog!)

## Feedback
Thanks for attending!
Please fill the feedback form: https://forms.gle/BS8sGxXRkFSydpKL8

repository: Breathedude/sosc-website

repo_name: Breathedude/sosc-website


text:
# Jekyll Port of Magnetic theme for my personal website.

Magnetic is a one page template with modern look and feel in mind based on the [original html5 theme](http://pixelhint.com/magnetic-free-html5-responsive-photography-website-template/).
I have used this html5 theme to make my own jekyll theme for my blog.

# Example Site

http://travel.abhishekbalam.xyz

# Features

* Image capable blog for documenting travels.
* Categories which are customisable for different types of travel.
* Map Feature - Where you can add coordinates to every place in a post and it shows up on a map , which makes it easy to navigate to for later perusing, or just to sit back and feel good about how far you travelled :)

## License

This theme is released under the MIT License (MIT).

## Acknowledgements

Thanks to

- [pixelhint.com](http://pixelhint.com) for creating this theme
- [Tom Preston-Werner](https://github.com/mojombo) for creating Jekyll and the awesome community around the project.

repository: abhishekbalam/magnetic-theme

repo_name: abhishekbalam/magnetic-theme


text:
# Oculus WebView Example

This Unity project demonstrates how to view and interact with web content in VR on Oculus Quest, Quest Pro, and Rift using [Vuplex 3D WebView](https://developer.vuplex.com/webview/overview). It includes the [Oculus Integration](https://assetstore.unity.com/packages/tools/integration/oculus-integration-82022) package, so the only additional thing you must import is one or more 3D WebView packages:

- For Oculus Quest / Quest Pro: [3D WebView for Android](https://store.vuplex.com/webview/android) (or the [Gecko package](https://support.vuplex.com/articles/android-comparison))
  - Note: 3D WebView's native Android plugins can't run in the editor, so a [mock webview](https://support.vuplex.com/articles/mock-webview) implementation is used by default while running in the editor unless [3D WebView for Windows and macOS](https://store.vuplex.com/webview/windows-mac) is also installed.
- For Oculus Rift: [3D WebView for Windows and macOS](https://store.vuplex.com/webview/windows-mac)

## Steps taken to create this project

1. Created a new project with Unity 2021.3.11.
2. Installed the [Oculus Integration package](https://assetstore.unity.com/packages/tools/integration/oculus-integration-82022) (v54.1).
3. Installed [3D WebView](https://developer.vuplex.com) ([.gitignore](https://github.com/vuplex/oculus-webview-example/blob/69d404181ba188937c124d154d7b1eab6173f609/.gitignore#L62)).
4. Created a new scene named OculusWebViewDemoScene to combine 3D WebView's [WebViewPrefab](https://developer.vuplex.com/webview/WebViewPrefab) and [Keyboard](https://developer.vuplex.com/webview/Keyboard) prefabs with the Oculus OVRCameraRig.
5. Added support for controllers by adding the Oculus [UIHelpers prefab](Assets/Oculus/SampleFramework/Core/DebugUI/Prefabs/UIHelpers.prefab) to the scene.
6. Made the following tweaks to the scene's UIHelpers prefab instance:
    - Updated the OVRInputModule script's "Ray Transform" and "Joypad Click Button" values
    - Disabled the Sphere cursor visual
    - Enabled the LaserPointer's line renderer and set its material

## License

The Oculus Integration library located in Assets/Oculus is Copyright © Facebook Technologies, LLC and its affiliates. All rights reserved. The Oculus Integration Library is licensed under the [Oculus SDK License](https://developer.oculus.com/licenses/sdk-3.5/).

All other code and assets are Copyright © Vuplex, Inc and licensed under the MIT License.

repository: vuplex/oculus-webview-example

repo_name: vuplex/oculus-webview-example


text:
# BestWeather

An exercise in optimism. Visit the deployed app [here](https://damp-beach-76188.herokuapp.com/weather).
View the backend code [here](github.com/amberjohnsonsmile/best-weather).

## Technologies
* React.js
* Node.js
* Material UI
* Java
* Spring Boot
* Gradle
* Heroku

## Running the App Locally
If you would like to run the React app locally, follow these steps:

1. Clone this repo and the [backend repo](github.com/amberjohnsonsmile/best-weather) to your local machine.

1. Follow steps in the backend repo to start the backend.

1. Navigate to the main directory of this repo and run `npm install`

1. Run `npm start`

1. View the app in your web browser at `localhost:3000`.

## Contact

Amber Johnson, Full Stack Web Developer

![headshot](https://user-images.githubusercontent.com/31632938/53816667-30666b80-3f21-11e9-81ff-6756194104a9.jpeg)
* Email<EMAIL_ADDRESS>* Portfolio [amberjohnsonsmile.co](https://amberjohnsonsmile.co)
* GitHub [@amberjohnsonsmile](https://github.com/amberjohnsonsmile)
* LinkedIn [@amberjohnsonsmile](https://linkedin.com/in/amberjohnsonsmile)

## License

MIT

repository: amberjohnsonsmile/best-weather-client

repo_name: amberjohnsonsmile/best-weather-client


text:
---
title: OnClientClicking
page_title: OnClientClicking - RadSplitButton
description: Check our Web Forms article about OnClientClicking.
slug: splitbutton/client-side-programming/events/onclientclicking
tags: onclientclicking
published: True
position: 3
---

# OnClientClicking

The clicking event occurs when the RadSplitButton control is clicked, immediately after the mouse button is released. The event is fired after the client-side validation occurs, and can be canceled.

The event handler receives two parameters:

1. The instance of the clicked RadSplitButton control

1. An eventArgs parameter of type [Telerik.Web.UI.**ButtonCancelEventArgs**](https://docs.telerik.com/devtools/aspnet-ajax/api/client/args/Telerik.Web.UI.ButtonCancelEventArgs), containing the following properties and methods:

	* get_cancel() - returns a bool value that indicates whether the event was canceled. True means the event is canceled.

	* set_cancel(*shouldCancel*) - sets a bool value that indicates whether the event will be canceled. Setting true means the event will be canceled.

	* get_commandName() - returns the value assigned to the RadSplitButton's **CommandName** property

	* get_commandArgument() - returns the value assigned to the RadSplitButton's **CommandArgument** property

This event comes handy in scenarios when the user wants to cancel the page submission, or prevent execution of the other client-side events based on a certain condition. One such scenario is confirming the submission of the page to the server. We ask the user if she wants to submit the page, and if a negative answer is received, we cancel the clicking event. Here is the code:

>caption Example 1: Handling OnClientClicking event in RadSplitButton.

````ASP.NET
<script type="text/javascript">
	function Clicking(sender, args)
	{
		args.set_cancel(!window.confirm("Are you sure you want to submit the page?"));
	}
</script>
<telerik:RadSplitButton ID="RadSplitButton1" runat="server" Text="Submit" OnClientClicking="Clicking" OnClick="RadSplitButton1_Click">
</telerik:RadSplitButton>
````

````C#
protected void RadSplitButton1_Click(object sender, System.EventArgs e)
{
	RadSplitButton1.Text = "RadSplitButton was clicked at: " + DateTime.Now.ToString();
}
````
````VB
Protected Sub RadSplitButton1_Click(ByVal sender As Object, ByVal e As System.EventArgs)
	RadSplitButton1.Text = "RadSplitButton was clicked at: " + DateTime.Now.ToString
End Sub
````

## See Also

 * [RadSplitButton - Client-side Events Demo](https://demos.telerik.com/aspnet-ajax/splitbutton/client-side-events/defaultcs.aspx)

 * [SplitButton Object]({%slug splitbutton/client-side-programming/splitbutton-object%})

 * [Telerik.Web.UI.ButtonCancelEventArgs](https://docs.telerik.com/devtools/aspnet-ajax/api/client/args/Telerik.Web.UI.ButtonCancelEventArgs)

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
---
template: DefaultPage
slug: logo_bbmd
title: Das ist das Logo der BBMD
featuredImage: 'https://ucarecdn.com/64c7d1af-abf5-4d32-be2f-331d7b074f69/'
meta:
  canonicalLink: hurz_bbmd_logo
  description: Hier hat sich der Gute ziemlich Mühe gegeben.
  title: Logo der BBMD
---
Post Two

This is placeholder text that our web designers put here to make sure words appear properly on your website. This text is going to be replaced once the website is completed. You are currently reading text that is written in English, not any other language. Be careful not to waste too much time reading placeholder text! This text isn’t going to remain here because it doesn't pertain to the website.

This paragraph has been copied from a program that automatically generates paragraphs like this. It is useful for web designers to use placeholder text so they can easily see what different fonts look like on a realistic paragraph.

repository: bodhicougar/gelbkuchen

repo_name: bodhicougar/gelbkuchen


text:
# docker-node-apidocjs
[apidocjs.com](http://apidocjs.com/) container used in builds of documentation
[Node.js 4.4.3 official](https://hub.docker.com/_/node/), and [apidocjs](http://apidocjs.com/)

Using this image at [Voxpopme](https://www.voxpopme.com) to ensure we have consistent builds of our documentation.

[![dockeri.co](http://dockeri.co/image/jujhars13/docker-node-apidocjs)](https://hub.docker.com/r/jujhars13/docker-node-apidocjs/)

### Usage
simply mount your project folder to `/app` and run the apidoc command as you usually would.

```
docker run --rm \
-v ${PWD}:/app \
jujhars13/docker-node-apidocjs \
apidoc -i api.superwidgets.com/ -o html/public -t template
```


text:
# Expressions

To evaluate JavaScript code inside the HTML use curly brackets `{}`.
Curly brackets can handle most of any valid JavaScript expressions.

```html
<div>{'Hello ' + 'World!'}</div>
```

Curly brackets allow to pass variables to the template.

```html
<div>Hello {name}!</div>
```

Inside the expression you can use built-in filters. Filters are responsible for easy mapping value to another form.

```html
<div>{hello | uppercase}</div>
```

```html
<div>{hello | lowercase | }</div>
```

The expression can be passed into a filter. Filters are responsible for transforming the value. They're simply a predefined functions that you can use. For more information, visit [pure-utilities](https://github.com/buxlabs/pure-utilities).

repository: inikonorov/boxwood

gha_license_id: MIT

repo_name: inikonorov/boxwood


text:
---
sidebar_position: 5
title: Custom Command to File
---

This command sends your CC(s) code in a text file, rather than "plain" Discord messages, preserving Tabs, markdown, etc.
You can specify more than one ID or trigger, and the bot will generate one file per input parameter. If none are provided, output will be the entire CC list.

**Trigger Type:** `Command`

**Trigger:** `cc2file`
Optional Trigger 2: `cc` IF you disable built-in `cc` command, via CommandOverrides

**Usage:**
`-cc2file <ID or Trigger> [ID or Trigger] [ID or Trigger]...`
For example: `-cc2file 10 "te st" 23`

```go
{{/*
	This command sends your CC(s) code in a text file, rather than "plain" Discord messages, preserving Tabs, markdown, etc.
	You can especify more than one ID or trigger, and bot will generate one file per input parameter. If none are provided, output will be CC list

	Trigger type: Command
	Recommended trigger 1: `cc2file`
	Recommended trigger 2: `cc` IF you disable built-in "cc" command, via CommandOverrides

	Usage: `-cc2file <ID or Trigger> [ID or Trigger] [ID or Trigger]...`. For example: `-cc2file 10 "te st" 23`

	Credits:
		- MatiasMFM2001: Main author
		- Joe L.: Reviewer
		- TheHDCrafter: Some Regex I've used
*/}}

{{/* CONFIGURATION AREA STARTS */}}
	{{/*If `true`, bot will do that. Prevents flood in the chat*/}}
	{{$limitTo5CCs:= true}}

	{{/*If `true`, the info of each CC will be included in the message content*/}}
	{{$CCInfo_MessageContent:= true}}

	{{/*If `true`, the info of each CC will be included in the attached file*/}}
	{{$CCInfo_Attachment:= false}}

	{{/*These CCs will NOT be processed. DON'T QUOTE THE NUMBERS NOR ADD "#" TO THEM*/}}
	{{$blacklisted_CCIDs:= cslice 1234 5678}}

	{{/*If false, blacklisted CCs will be strikethroughted from CC list. If true, they will be left out*/}}
	{{$hideBlacklistedCCs:= false}}
{{/* CONFIGURATION AREA ENDS */}}

{{/*
	sendLongMessage is able to split a long text and send them in individual messages (of 2000 chars long max)

	INPUT (arguments) is an SDICT with keys:
		[String/Int/nil] "channelID" = Channel ID/Name/nil where message(s) will be sent
		[String] "text" = The content itself you want to send
		[String] "separator" = This will define when a 'word' starts or ends
*/}}
{{define "sendLongMessage"}}
	{{$outStr:= ""}}

	{{/*If separator is not found on the text, fallback to a default empty string*/}}
	{{if not (in .text .separator)}}
		{{.Set "separator" ""}}
	{{end}}

	{{/*Split text in 'words' and iterate over them*/}}
	{{range (split .text .separator)}}
		{{/*Keep appending words while length is under the limit. Then, send the message and "reset" the content for a new message*/}}
		{{- if gt (add (len $outStr) (len .)) 2000}}
			{{- sendMessage $.channelID $outStr}}
			{{- $outStr = .}}
		{{- else}}
			{{- $outStr = joinStr $.separator $outStr .}}
		{{- end -}}
	{{end}}

	{{/*Send the last message, that was left when range loop ended*/}}
	{{sendMessage .channelID $outStr}}
{{end}}

{{/*
	parseCC executes "-cc .argument" and extracts all possible information from it

	INPUT is an SDICT with keys:
		[String] "argument" = The CC ID or Trigger to parse

	OUTPUT is the same SDICT with keys:
		[String] "error" = If there are errors, they will be returned here (as a string)
		[Int] "CCID" = The ID of processed CC
		[String] "triggerType" = The type of the trigger this CC has (i.e. "None", "Command", "Regex", etc)
		[String] "trigger" = The trigger itself this CC has (i.e. "cc2file", ".*", etc)
		[Bool] "caseSensitive" = If lowercase and uppercase characters, are not considered equal
		[String] "group" = CC group, this CC belongs to
		[String] "code" = Executable source code of this CC
*/}}
{{define "parseCC"}}
	{{/*EXECute "-cc" and extract stuff from its output*/}}
	{{$answer:= exec "cc" .argument}}
	{{$answerLines:= split $answer "\n"}}
	{{$extractedCode:= slice $answerLines 2 (sub (len $answerLines) 1)}}
	{{$firstLine:= index $answerLines 0}}

	{{/*Check if Answer's $firstLine is actually an error message*/}}
	{{- if in $firstLine "here is a list of"}}
		{{.Set "error" (printf "❌ CC `%s` not found" .argument)}}
	{{- else if in $firstLine "More than 1 matched command"}}
		{{/*Insert argument in message output, and if it's empty, replace it with "<Empty trigger specified>"*/}}
		{{.Set "error" (reReplace "``" (printf "`%s`: %s" .argument $answer) "`<Empty trigger specified>`")}}
	{{end}}

	{{/*If not, extract info from the CC*/}}
	{{if not .error}}
		{{/*Modified copy of TheHDCrafter's Regex expression. Licensed under MIT*/}}
		{{$parsedFirstLine:= reFindAllSubmatches `^#\s*(\d+) - ((.*)(?:(?:: \x60(.*)\x60 - Case sensitive trigger: \x60(.+)\x60)|\b))? - Group: \x60(.+)\x60$` $firstLine}}

		{{.Set "CCID" (index $parsedFirstLine 0 1 | toInt)}}
		{{.Set "triggerType" (or (index $parsedFirstLine 0 3) "None")}}
		{{.Set "trigger" (index $parsedFirstLine 0 4)}}
		{{.Set "caseSensitive" (index $parsedFirstLine 0 5 | eq "true")}}
		{{.Set "group" (index $parsedFirstLine 0 6)}}

		{{.Set "code" (joinStr "\n" $extractedCode)}}
	{{end}}
{{end}}

{{/*EXECUTION STARTS HERE*/}}
{{/*If CC was called via execCC/scheduleUniqueCC, use .ExecData as the $args. If not, use .CmdArgs*/}}
{{$args:= cslice}}
{{with .ExecData}}
	{{$args = .}}
{{else}}
	{{/*Delete duplicated $args*/}}
	{{range .CmdArgs}}
		{{- if not (in $args .)}}
			{{- $args = $args.Append .}}
		{{- end}}
	{{- end}}
{{end}}
{{$numArgs:= len $args}}

{{/*Exec can be called 5 times max, so $selectedArgs will have up to 5 $args to be processed*/}}
{{$selectedArgs:= cslice}}
{{if gt $numArgs 5}}
	{{$selectedArgs = slice $args 0 5}}

	{{if $limitTo5CCs}}
		{{sendMessage nil "⚠ WARNING: Only first 5 CCs will be processed"}}
	{{end}}
{{else}}
	{{$selectedArgs = $args}}
{{end}}

{{/*Process each selected argument in this execution*/}}
{{range $selectedArgs}}
	{{- $params:= sdict "argument" .}}
	{{- template "parseCC" $params}}

	{{/*Check if that CC was $blacklisted*/}}
	{{- if $params.error}}
		{{- sendMessage nil $params.error}}
	{{- else if in $blacklisted_CCIDs $params.CCID}}
		{{- sendMessage nil (printf "🚫 CC `%s` is blacklisted" .)}}
	{{- else}}
		{{/*No error message, so send CC's code and info*/}}
		{{- $content:= ""}}
		{{- $attachment:= $params.code}}

		{{/*If $CCInfo_MessageContent flag is set, the info will be sent as message content*/}}
		{{- if $CCInfo_MessageContent}}
			{{- $content = printf "#%d - %s: `%s` - Case sensitive trigger: `%t` - Group: `%s`" $params.CCID $params.triggerType $params.trigger $params.caseSensitive $params.group}}
		{{- end}}

		{{/*If $CCInfo_Attachment flag is set, the info will be a comment in message's attachment*/}}
		{{- if $CCInfo_Attachment}}
			{{/*Generate the $leadingComment*/}}
			{{- $leadingComment:= printf "{{/*\n\tDescription:\n\n\tUsage:\n"}}

			{{- range reFindAllSubmatches `parseArgs\s+\d+\s+"(.+)"` $params.code}}
				{{- $leadingComment = printf "%s\t\t\"%s\"\n" $leadingComment (index . 1)}}
			{{- end}}

			{{- $leadingComment = printf "%s\n\tRecomended trigger: \"%s\"\n\tTrigger type: %s\n\n\tCredits:\n*/}}" $leadingComment $params.trigger $params.triggerType}}

			{{- $attachment = printf "%s\n\n%s" $leadingComment $attachment}}
		{{- end}}

		{{- sendMessage nil (complexMessage
			"content" $content
			"file" $attachment
		)}}
	{{- end}}

	{{- sleep 1}}
{{else}}
	{{/*If there are 0 args, send full CC list*/}}
	{{$answerLines:= split (exec "cc") "\n"}}

	{{/*Save the first line, and the rest of them, in different variables*/}}
	{{$newMessage:= index $answerLines 0}}
	{{$answerLines:= slice $answerLines 1 (sub (len $answerLines) 1) | cslice.AppendSlice}}

	{{/*For each CC, if It's blacklisted, strikethrough whole line*/}}
	{{range $index, $content:= $answerLines}}
		{{- $CCID:= index (reFindAllSubmatches `^\x60#([0-9 ]{3})` $content) 0 1 | toInt}}

		{{- if in $blacklisted_CCIDs $CCID}}
			{{- if $hideBlacklistedCCs}}
				{{- $answerLines.Set $index ""}}
			{{- else}}
				{{- $answerLines.Set $index (printf "~~%s~~" $content)}}
			{{- end}}
		{{- end}}
	{{end}}

	{{/*A DIY "joinStr `\n` $answerLines"*/}}
	{{range $answerLines}}
		{{- $newMessage = printf "%s\n%s" $newMessage .}}
	{{end}}

	{{template "sendLongMessage" (sdict "channelID" nil "text" $newMessage "separator" "\n")}}
{{end}}

{{/*If $limitTo5CCs flag is not set, and there are still arguments left, execute CC again to process them*/}}
{{if and (not $limitTo5CCs) (gt $numArgs 5)}}
	{{scheduleUniqueCC .CCID nil 1 "cc2file - remaining args" (slice $args 5 $numArgs)}}
{{end}}
```


text:
# R7RS standard libraries for Akku.scm

[Akku.scm](https://akkuscm.org/) has the ability to convert R7RS
`define-library` forms to R6RS `library` forms. This package provides
the R7RS standard library for use with such converted libraries.

These libraries will not work properly unless they are installed by
Akku.scm version 0.3.0 or later. They need the information in the
`(akku metadata)` library.

## Current status

* Chez Scheme - works
* GNU Guile - works
* Ikarus - missing support for `u8-ready?`, `char-ready?`, and
  `open-output-bytevector`
* IronScheme - full test suite segfaults Mono
* Larceny - already supports R7RS, tests crash on `vector-map`
* Loko Scheme - fails due to missing a SRFI 38 compatibility library
* Mosh - full test suite fails with a conflicting import
* Racket - conflicts with `(scheme base)`, need to figure out a way to
  use [racket-r7rs](https://github.com/lexi-lambda/racket-r7rs) instead
* Sagittarius - already supports R7RS
* Vicare - full test suite fails from static type checking
* Ypsilon - incompatible with SRFI-43 from `chez-srfi` (should be fixed)

## Credits

The code in this repository is in part based on yuni by okuoku:
https://github.com/okuoku/yuni

## License

akku-r7rs - R7RS compatibility libraries for Akku

Written in 2014-2018 by OKUMURA Yuki<EMAIL_ADDRESS>
Written in 2018-2020 by Göran Weinholt<EMAIL_ADDRESS>
To the extent possible under law, the author(s) have dedicated all
copyright and related and neighboring rights to this software to
the public domain worldwide. This software is distributed without
any warranty.

You should have received a copy of the CC0 Public Domain Dedication
along with this software. If not, see
<http://creativecommons.org/publicdomain/zero/1.0/>.


text:
---
layout: default
---

# 1993-09-23 - No Subject

## Header Data

From: Anonymous<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 02aa0a0d28be836ecdad10488772a0801594f9d791283eb1b27ef6485339a726

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-09-23 16:17:17 UTC

Raw Date: Thu, 23 Sep 93 09:17:17 PDT

## Raw message

```
{% raw  %}From: Anonymous<EMAIL_ADDRESS>Date: Thu, 23 Sep 93 09:17:17 PDT
To<EMAIL_ADDRESS>Subject: No Subject
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

OK, now for something completely different:

A few years back, a sculpture was created and presented to the CIA by
an artist who inscribed the base of the work with a cyphertext.  He
refused to tell anyone what it said, but I think he later acquiesced
and told the DCI.  Has anyone heard anything more about this?  Was
the cypher cracked?

{% endraw %}
```

## Thread

+ Return to [September 1993](/archive/1993/09)

+ Return to "[Anonymous <nowhere@bsu-cs.bsu.edu>](/authors/anonymous_nowhere_at_bsucs_bsu_edu_)"

+ 1993-09-23 (Thu, 23 Sep 93 09:17:17 PDT) - No Subject - _Anonymous<EMAIL_ADDRESS>


text:
## Headless mode

Headless mode is a version of this game that is ran without a ui, in your command prompt / terminal

Here are the steps to use:
- Download nodejs - https://nodejs.org
- Download https://github.com/meepen/salien-bot/archive/master.zip
- Extract salien-bot-master.zip
- Open command line in salien-bot-master
- Write
```
npm install
notepad gettoken.json
```
- Log into Steam
- Open https://steamcommunity.com/saliengame/gettoken in browser with steam logged in
- Copy the entire contents of the page
- Paste into notepad and save the file as `gettoken.json`.
- (IMPORTANT) Immediately copy something else to avoid accidentally giving this out to someone else!
- Save and exit
- Back to command line:
```
node headless
```
#### If you want automatic restart in case of crash:

Open command line/terminal and write:
```
npm i -g pm2
```
To start bot:
```
pm2 start headless.js
```
![alt-text](https://i.imgur.com/CPTz57y.png)

Now the bot is running. If there is a crash, it restarts itself. You can close command line/terminal (yes, it doesn't require a running cmd window or anything else).

To view the log open the terminal and write:
```
pm2 log
```
To close log use `Ctrl + C`

To stop bot:
```
pm2 delete id/all
```
For first app id is 0, for second - 1... Also, you can see ID in the list of running applications:
To see a list of all running bots:
```
pm2 list
```

### Tile selection

By default it will scour all available planets and get the highest exp rewards from difficult tiles, if you don't want this, run the bot with
```
node headless --care-for-planet
```

## Userscript mode

Salien bot is a WIP for the Salien Minigame that came out for Steam Summer Sale 2018.

I picked this up because it reminded me of a challenge in programming I had before. I won't be manipulating any state, just injecting mouse clicks and other button presses.

To use, copy and paste index.user.js in console, or use GreaseMonkey or TamperMonkey and visit https://github.com/meepen/salien-bot/raw/master/index.user.js

Also, a note: playing this game AT ALL will not net you better rewards! It's only the time you have been on the page. No need to waste computer resources :)

### Tile selection

The tile select code focuses on levelling up to level 13 on hard tiles; after you hit level 9 it will try and target the highest progress tile

repository: BoberMod/salien-bot-test

repo_name: BoberMod/salien-bot-test


text:
# docker-winevnc
Docker image to provide a simple vnc server with Wine. This image has also a menu entry for Winbox (Mikrotik)

## Create Dockerfiles
In order to create Dockerfiles you need jinja templating engine (Python). You can install it running the commands below:

```
pip install jinja2 jinja2-cli
```

## Expose winbox
If you want to run winbox you need to mount a volume with `winbox64.exe` executable.

```
docker run -v <your-dir>:/volume
```

## Run example

```
docker run -d --restart always -p <IP_ADDRESS>:5900:5900 -v /opt/winevnc:/volume glutec/winevnc:latest
```

repository: glutechnologies/docker-winevnc

branch_name: refs/heads/main

repo_name: glutechnologies/docker-winevnc


text:
# Reference
<!-- DO NOT EDIT: This document was generated by Puppet Strings -->

## Table of Contents

**Resource types**

* [`rbac_group`](#rbac_group): A Puppet Enterprise Console RBAC group
* [`rbac_role`](#rbac_role): A Puppet Enterprise Console RBAC role
* [`rbac_user`](#rbac_user): A Puppet Enterprise Console RBAC user

## Resource types

### rbac_group

A Puppet Enterprise Console RBAC group

#### Properties

The following properties are available in the `rbac_group` type.

##### `ensure`

Valid values: present, absent

The basic property that the resource should be in.

Default value: present

##### `roles`

Array of role names for the group

##### `id`

The read-only ID of the group

#### Parameters

The following parameters are available in the `rbac_group` type.

##### `name`

namevar

The name of the group

### rbac_role

A Puppet Enterprise Console RBAC role

#### Properties

The following properties are available in the `rbac_role` type.

##### `ensure`

Valid values: present, absent

The basic property that the resource should be in.

Default value: present

##### `description`

The description of the role

##### `permissions`

Array of permission objects for the role

##### `user_ids`

Array of UUIDs of users (or names) assigned to the role

##### `group_ids`

Array of UUIDs of groups assigned to the role

##### `id`

The read-only ID of the role

#### Parameters

The following parameters are available in the `rbac_role` type.

##### `name`

namevar

The displayed name of the role

### rbac_user

A Puppet Enterprise Console RBAC user

#### Properties

The following properties are available in the `rbac_user` type.

##### `ensure`

Valid values: present, absent

The basic property that the resource should be in.

Default value: present

##### `display_name`

The displayed name of the user

##### `email`

Valid values: /@/

The email address of the user

##### `password`

The plaintext password of the user.

##### `roles`

List of role IDs the user is a member of. The only attribute which can be changed after creation.

Default value: [3]

##### `id`

The read-only ID of the user

##### `remote`

Remote users are managed by an external directory service

##### `superuser`

Whether this user has superuser privileges

##### `last_login`

The last login time for this user

#### Parameters

The following parameters are available in the `rbac_user` type.

##### `name`

Valid values: /^\S+$/

namevar

Login name of the user

repository: puppetlabs/pltraining-rbac

gha_language: Ruby

repo_name: puppetlabs/pltraining-rbac


text:
# Lab 6
Create a Restaurant class and Review class and associate them

## Tasks
- Create a class to represent a Restaurant. Each Restaurant should have a name, a number of stars betweeen 0 and 5, and a price category (i.e. number of dollar signs).
    - Implement a Restaurant constructor.
    - Test that your Restaurant constructor is behaving reasonably.
    - Implement a reasonable toString method for Restaurants.
    - Write a test to create an instance of Restaurant and ensure that its toString is working properly.
- Create a class to represent a Review. Each Review should have a body, an author, and a number of stars.
    - Write a Review constructor.
    - Test that your constructor is working reasonably.
    - Implement a reasonable toString method for Reviews.
    - Write a test to create an instance of Review and ensure that its toString is working properly.
- A Review should be about a single Restaurant. Choose an implementation for this, and implement it. Some considerations:
    - Should a Review know which Restaurant it is about?
    - Should a Restaurant know which Reviews are about it?
    - Is a Restaurant a special type of Review? Is a Review a special type of Restaurant? Is there common functionality that unites them?
    - Update your toString and constructor methods appropriately, and also update your testing code to test this new functionality.
- Add an instance method addReview to your Restaurant class. This method should take in a Review instance, and associate that review with this Restaurant. The specific methodology for this will vary, depending on the implementation you chose above.
    - Add tests to ensure that when you call addReview, the association is created between the Restaurant and the Review.
- When you associate a review with a restaurant, that restaurant’s star rating should change. Ensure that your addReview method updates the Restaurant star rating appropriately, and add tests. (In particular, ensure that if you’re trying to call addReview when the restaurant and the review are already associated, the star rating of the restaurant does not update.)

## Library Architecture
- Class Restaurant
    - constuctor (name, location, Employee list, Review list)
    - getters
        - getName
        - getLocation
        - getAvgStars
        - getEmployees
    - addReview
    - toString
- Class Review
    - constructor(user, userReview, stars)
    - getters
        - getUser
        - getReview
        - getRestaurantName
        - getStars
    - setters
        - setRestaurantName
    - toString
# Test
* [Test code](https://github.com/mattburger/java-fundamentals/blob/master/basiclibrary/src/test/java/inheritance/TestRestaurant.java)
- You can add parameters to the test code to further test other bounds and cases.

repository: mattburger/java-fundamentals

gha_language: Java

repo_name: mattburger/java-fundamentals


text:
---
layout: default
title: Module specifications
nav_order: 50
parent: Parameters
---

# Module specifications

{: .fs-5}
{: .fw-400}
**Most users will not need to modify the default `modules` specifications, unless you want to:**
1. Run a different version of an existing module, or
2. Add another module
{: .fs-5}
{: .fw-400}

The following page describes how to use the `modules:` namespace of the [parameter file]({{site.baseurl}}/parameters/) to accomplish either of these goals.
{: .fs-5}
{: .fw-400}

---

    Table of contents

  {: .text-delta }
1. TOC
{:toc}

---

## Modifying a module version

If a module is specified as the only option for a given processing step (`illumination`, `registration`, `dearray`, `watershed`, `quantification` and `viz`), then the version should be specified directly under the corresponding step using the `version:` field. In this case, an example `params.yml` may look as follows:

``` yaml
modules:
  registration:
    version: 1.16.0
  watershed:
    version: 1.4.0-large
```

Alternatively, if a module is one of several options for a given processing step (currently only `segmentation` and `downstream`), then the version specification should also include a `name:` field to allow matching against existing modules. An example `params.yml` in this case may look as following:

``` yaml
modules:
  segmentation:
    -
      name: unmicst
      version: 2.7.3
    -
      name: mesmer
      version: 0.4.0
  downstream:
    -
      name: naivestates
      version: 1.6.2
```

When in doubt, follow the same structure as the one represented by the [default values](https://github.com/labsyspharm/mcmicro/blob/master/config/defaults.yml){:target="_blank"}.

## Adding a module

Adding a new module specification is currently only possible for `segmentation` and `downstream` processing steps.

### Input and output specs

Every module must have a command-line interface (CLI) that has been encapsulated inside a Docker container.
MCMICRO assumes that CLI conforms to the following input-output specifications.

### Segmentation modules

**Input:**

* A file in `.ome.tif` format containing a fully stitched and registered multiplexed image.
* (Optional) A file containing a custom model for the algorithm. The file can be in any format, and it is up to the module developer to decide what formats they allow from users.

**Output:**

* An image file in `.tif` format, written to `.` (i.e., the "current working directory"). The file can be either a probability map or a segmentation mask. The image channels in probability maps annotate each pixel with probabilities that it belongs to the background or different parts of the cell such as the nucleus, cytoplasm, cell membrane or the intercellular region. Similarly, segmentation masks annotate each pixel with an integer index of the cell it belongs to, or 0 if none.
* (Optional) One or more files written to `./qc/` (i.e., `qc/` subdirectory within the "current working directory"). These will be copied by the pipeline to the corresponding location in the [project's `qc/` directory]({{ site.baseurl }}/io.html#quality-control).

### Downstream modules

**Input:**

* A file in `.csv` format containing a [spatial feature table]({{ site.baseurl }}/io.html#quantification). Each row in a table corresponds to a cell, while columns contain features characterizing marker expression or morphological properties.
* (Optional) A file containing a custom model for the algorithm. The file can be in any format, and it is up to the module developer to decide what formats they allow from users.

**Output:**

* One or more files in `.csv` or `.hdf5` format, written to `.` (i.e., the "current working directory"). Each file should annotate individual cells with the corresponding inferred cell state.
* (Optional) One or more files written to `./plots/` (i.e., `plots/` subdirectory within the "current working directory"). Each file can be in any format and contain any information that the module developer thinks will be useful to the user (e.g., UMAP plots showing how cells cluster together).
* (Optional) One or more files written to `./qc/` (i.e., `qc/` subdirectory within the "current working directory"). These will be copied by the pipeline to the corresponding location in the [project's `qc/` directory]({{ site.baseurl }}/io.html#quality-control).

# Configuration

Adding a new MCMICRO module involves specifying simple key-value pairs in the `modules:` section of `params.yml`. For example, consider the following configuration for ilastik:

``` yaml
modules:
  segmentation:
    -
      name: ilastik
      container: labsyspharm/mcmicro-ilastik
      version: 1.4.5
      cmd: python /app/mc-ilastik.py --output .
      input: --input
      model: --model
      channel: --channelIDs
      idxbase: 1
      watershed: 'yes'
```

## Name

The `name` of the module determines two things. First, it specifies the names of subdirectories for where the output files will be written to in the project directory. In the given example, the primary outputs will appear in `probability-maps/ilastik/`, while QC files will be written to `qc/ilastik/`. Second, the module name also tells MCMICRO what other parameters to look for. In our example, the pipeline will look for module specific parameters in `--ilastik-opts` and a custom model file in `--ilastik-model`.

## Container and version

The two fields must uniquely identify a Docker container image containing the tool. Mechanistically, the fields are combined using the [standard `REPOSITORY:TAG` convention](https://docs.docker.com/engine/reference/commandline/images/).

## Command

The `cmd` field must contain a command that, when executed inside the container, will produce the required set of outputs from the inputs provided to it by the pipeline.

**It is imperative that all primary outputs are written to `.` (i.e., the "current working directory"). MCMICRO will automatically sort outputs to their correct location in the project directory. Writing outputs to any other location may result in MCMICRO failing to locate them.**

## Input

The `input` field determines how the pipeline will supply inputs to the module. Some examples in the context of [exemplar-001]({{ site.baseurl }}/datasets/) may look as follows:

| Configuration | What MCMICRO will execute |
| :-- | :-- |
| cmd   : 'python /app/tool.py -o .'
input : '-i'  | `python /app/tool.py -o . -i exemplar-001.ome.tif` |
| cmd   : 'python /app/tool.py -o .'
input : '--input'  | `python /app/tool.py -o . --input exemplar-001.ome.tif` |
| cmd   : 'python /app/tool.py -o .'
input : ''  | `python /app/tool.py -o . exemplar-001.ome.tif` |

## (Optional) Model

The `model` field functions similarly to `input` and specifies how the pipeline will supply a custom model to the tool. In this example, MCMICRO will check whether the user specified `--ilastik-model` in the calling arguments, and pass the corresponding value to ilastik via `--model`.

## (Optional) Channel and indexing base

The `channel` field indicates how MCMICRO should pass `--segmentation-channel` value(s) specified by the user to the module. The `idxbase` field specifies whether the module assumes 0-based or 1-based indexing. All channel indexing in MCMICRO starts with 1, and the pipeline will correctly account for 0-based indexing, if it used by the module.

## Watershed

The `watershed` field specifies whether the module requires a subsequent watershed step. Set it to `'yes'` for modules that produce probability maps and `'no'` for instance segmenters. Alternatively, you can specify `'bypass'` to have the output still go through S3Segmenter with the `--nucleiRegion bypass` flag. This will skip watershed but still allow you to filter nuclei by size with `--logSigma`.

## Putting it all together

Given the above configuration for ilastik, users of MCMICRO can begin using the module by including the following inside their `params.yml`:

``` yaml
workflow:
  segmentation: ilastik
  segmentation-channel: 1 5
  ilastik-model: myawesomemodel.ilp
options:
  ilastik: --num_channels 2
```

As exemplar-001 makes its way through the pipeline, it will eventually encounter the [segmentation step]({{ site.baseurl }}/io.html#segmentation). The pipeline will then identify ilastik as the module to be executed from the `--segmentation` flag. The actual command that MCMICRO runs will then be composed using all the above fields together:

```
python /app/mc-ilastik.py --output . --input exemplar-001.ome.tif --model myawesomemodel.ilp --channelIDs 1 5 --num_channels 2
```

repository: labsyspharm/mcmicro

gha_language: Nextflow

repo_name: labsyspharm/mcmicro


text:
# Encode/Rebuild (ER)

[![er build only](https://github.com/ECP-VeloC/er/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/ECP-VeloC/er/actions/workflows/build-and-test.yml)

# Overview
This module combines the funcitonality of shuffile and redset,
which lets both migrate and rebuild files within an MPI job.
It is useful for moving and rebuilding data files on distributed storage, e.g., node-local storage,
particularly when MPI ranks may be running on different compute nodes than when they originally created their files.

To encode, one defines a redundancy scheme and then applies the redundancy scheme to a list of files also providing a name for the encoded set.
To rebuild, one specifies the name of the encoded set.
Additionally, there is a function to remove the encoding information, which is needed when removing a dataset.

Currently, er assumes the group of processes participating is the same as MPI_COMM_WORLD.

Usage is documented in [src/er.h](src/er.h) and in the [user API](https://ecp-veloc.github.io/component-user-docs/group__er.html) docs.

# Building

To build dependencies:

    git clone git@github.com:ECP-VeloC/KVTree.git   KVTree.git
    git clone git@github.com:ECP-VeloC/rankstr.git  rankstr.git
    git clone git@github.com:ECP-VeloC/redset.git   redset.git
    git clone git@github.com:ECP-VeloC/shuffile.git shuffile.git

    mkdir install

    rm -rf build
    mkdir build
    cd build
    cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=../install -DMPI=ON ../KVTree.git
    make clean
    make
    make install
    cd ..

    rm -rf build
    mkdir build
    cd build
    cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=../install -DMPI=ON ../rankstr.git
    make clean
    make
    make install
    cd ..

    rm -rf build
    mkdir build
    cd build
    cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=../install -DMPI=ON ../redset.git
    make clean
    make
    make install
    cd ..

    rm -rf build
    mkdir build
    cd build
    cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=../install -DMPI=ON ../shuffile.git
    make clean
    make
    make install
    cd ..

To build ER:

    cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=./install -DWITH_KVTREE_PREFIX=`pwd`/install -DWITH_RANKSTR_PREFIX=`pwd`/install -DWITH_REDSET_PREFIX=`pwd`/install -DWITH_SHUFFILE_PREFIX=`pwd`/install .
    make

# Testing
Some simple test programs exist in the test directory.

To build a test for the ER API:

    mpicc -g -O0 -o test_er test_er.c -I../install/include -L../install/lib64 -lkvtree -lshuffile -lredset -lrankstr -I../src -L../src -ler

## Release

Copyright (c) 2018, Lawrence Livermore National Security, LLC.
Produced at the Lawrence Livermore National Laboratory.
<br>
Copyright (c) 2018, UChicago Argonne LLC, operator of Argonne National Laboratory.

For release details and restrictions, please read the [LICENSE]() and [NOTICE]() files.

`LLNL-CODE-751725` `OCEC-18-060`

repository: ECP-VeloC/er

gha_language: C

repo_name: ECP-VeloC/er


text:
## Augur Setup

## General Pre-Requisites
### Frontend (Optional)
1. Install NodeJS (Optional if only running the backend) `sudo apt update` and `sudo apt install nodejs`
2. Install NPM (Optional if only running the backend) `sudo apt install npm`
3. Install nvm (node version manager: recommended) `sudo apt install curl` and `curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash`
3. Install vue.js (Optional if only running the backend)
4. Install vue-cli (Optional if only running the backend)

### Backend (Ubuntu instructions, use Linux Distro Appropriate Package Manager Otherwise)
1. Obtain a GitHub Access Token: https://github.com/settings/tokens
2. Obtain a GitLab Access Token: https://gitlab.com/-/profile/personal_access_tokens
3. Python3 needs to be installed, and typically is by default on most systems.
4. There are some Git configuration parameters that help when you are cloning repos over time, and a platform prompts you for credentials when it finds a repo is deleted:
```bash
    git config --global diff.renames true
    git config --global diff.renameLimit 200000
    git config --global credential.helper cache
    git config --global credential.helper 'cache --timeout=9999999999999'
```
5. Make sure all of your core libraries are installed at the operating system level. Often, these days, they are by default, and its important to make sure:
```bash
    sudo apt update
    sudo apt upgrade
    sudo apt install software-properties-common
    sudo apt install python3-dev
    sudo apt install postgresql postgresql-contrib postgresql-client
    sudo apt install build-essential
```
6. If you are running on Ubuntu 22.x right now, you will need to install python 3.9
  - `sudo add-apt-repository ppa:deadsnakes/ppa`
  - `sudo apt install python3.9`
  - `sudo apt install python3.9-distutils`
7. Install pip: `sudo apt install python3-pip` and `sudo apt install python3.9-venv`

### Docker
1. Make sure docker, and docker-compose are both installed
2. Modify the `environment.txt` file in the root of the repository to include your GitHub and GitLab API keys.
3. If you are already running postgresql on your server you have two choices:
   - Change the port mappings in the `docker-compose.yml` file to match ports for Postgresql not currently in use.
   - Change to variables in `environment.txt` to include the correct values for your local, non-docker-container database.
4. `sudo docker build -t augur-new -f docker/backend/Dockerfile .`
5. `sudo docker-compose --env-file ./environment.txt --file docker-compose.yml up` to run the database in a Docker Container or
   `sudo docker-compose --env-file ./environment.txt --file docker-compose.yml up` to connect to an already running database.

### Regular Installation
0. Follow the installation instructions for the database here: https://oss-augur.readthedocs.io/en/main/quick-start.html#postgresql-installation
1. Clone Augur, or clone your fork of Augur if you wish to make contributions
2. Install `redis-server` at the operating system level `sudo apt install redis-server`
3. Make sure you have `Go` version is 1.19.3. If you don't know how to install `Go`, instructions are provided during the installation process. After following the instructions, you will need to add Go to your path for this session: `export PATH=$PATH:/usr/local/go/bin`. You should also add this to your shell's profile script.
4. Create a Python Virtual Environment `python3 -m venv ~/virtual-env-directory` (use `python3.9 -m venv` if on Ubuntu 22.04, as it defaults to python 3.10, which will not compile the machine learning workers.)
5. Activate your Python Virtual Environment `source ~/virtual-env-directory/bin/activate`
6. From the root of the Augur Directory, type `make install`
7. You will be prompted to provide your GitHub username and password, your GitLab username and password, and the postgresql database where you want to have the Augur Schema built. You will also be prompted to provide a directory where repositories will be clone into.
8. To access command line options, use `augur --help`. To load repos from GitHub organizations prior to collection, or in other ways, the direct route is `augur db --help`.
9. Start a Flower Dashboard, which you can use to monitor progress, and report any failed processes as issues on the Augur GitHub site. The error rate for tasks is currently 0.04%, and most errors involve unhandled platform API timeouts. We continue to identify and add fixes to handle these errors through additional retries. Starting Flower: `(nohup celery -A augur.tasks.init.celery_app.celery_app flower --port=8400 --max-tasks=1000000 &)` NOTE: You can use any open port on your server, and access the dashboard in a browser with http://servername-or-ip:8400 in the example above (assuming you have access to that port, and its open on your network.)
10. Start Augur: `(nohup augur backend start &)`
11. When data collection is complete you will see only a single task running in your flower Dashboard.
12. You can stop augur with `augur backend stop`, followed by `augur backend kill`. We recommend waiting 5 minutes between commands so Augur can shutdown more gently. There is no issue with data integrity if you issue them seconds apart, its just that stopping is nicer than killing.
13. If you wish to run the frontend, create a file called `frontend/frontend.config.json following this structure, with relevant values`: (Default port is 5000. This can be changed in the `augur_operations.config` table.). Then run `npm install` and `npm run build` in the frontend directory. `npm run serve will make a development server (usually on your local machine)` version of the frontend available. If you wish to run Augur's frontend through nginx, you can follow these instructions here: https://oss-augur.readthedocs.io/en/augur-new/deployment/nginx-configuration.html?highlight=nginx#nginx and here: https://oss-augur.readthedocs.io/en/augur-new/deployment/nginx-configuration.html?highlight=nginx#site-configuration
NOTE: `"host": "your resolvable server"`
    ```json
    {
        "Frontend": {
            "host": "chaoss.tv",
            "port": 5000,
            "ssl": false
        },
        "Server": {
            "cache_expire": "3600",
            "host": "<IP_ADDRESS>",
            "port": 5000,
            "workers": 6,
            "timeout": 6000,
            "ssl": false,
            "ssl_cert_file": null,
            "ssl_key_file": null
        }
    }
    ```
14. If you have frontend configuration issues that result in a *failure* to complete steps with npm, we recommend you install and use `nvm`: https://tecadmin.net/how-to-install-nvm-on-ubuntu-20-04/ to set your nodejs release to the latest LTS of 12.x or 16.x. For example: `nvm ls-remote | grep -i 'latest'` and `nvm alias default 16.??` (whatever the latest version of 16 is.)
15. Also, please explore our new frontend, being developed at https://github.com/augurlabs/augur_view. The `dev` branch is the most current.

repository: MUSoftwareEngineering/augur

repo_name: MUSoftwareEngineering/augur


text:
---
layout: default
---

# 1997-04-08 - Blanc Weber / Positivist Schill

## Header Data

From: Toto<EMAIL_ADDRESS>To: Blanc Weber<EMAIL_ADDRESS>Message Hash: 43bb3bbc674476a78f89ff2a562a3d385fa3c7ba5b1000b07e44fc84164ba37d

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-04-08 04:23:16 UTC

Raw Date: Mon, 7 Apr 1997 21:23:16 -0700 (PDT)

## Raw message

```
{% raw  %}From: Toto<EMAIL_ADDRESS>Date: Mon, 7 Apr 1997 21:23:16 -0700 (PDT)
To: Blanc Weber<EMAIL_ADDRESS>Subject: Blanc Weber / Positivist Schill
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Blanc Weber wrote:
> ---------------------------------------------------
> In "Human Action", by Ludwig von Mises, he explains very well how
> nations which restrict their market options create the tensions and
> circumstances which lead to wars between them.

  All of the good computer gurus I know have degrees in Political
Philosophy, and the like. You must be one of them.

> I was considering, likewise, that the current developing technologies
> might open up people's imagination to so many interesting things to do
> and new ways to get what they are after, creating a sense of
> "possibility", rather than "impossibility", that this would affect their
> outlook on life and their attitude and turn their attention to more
> positive things beyond killing - that is, beyond the idea of achieving
> freedom from certain influences by killing the source of those
> influences.

  Are you part of a cypherpunks list conspiracy to balance my
cynicism? Are you actually suggesting that there may be a spark
of hope for mankind to prevail in the battle with the forces of
mindless robotic sheepnocity?

> In the "new world order", those influences would not be so threatening,
> as there would exist ways to route around them.  This could reduce the
> tensions which would otherwise arise, leaving the mind open to more
> productive considerations, freed to think less in terms of destructive
> methodologies.

  You seem to be one of the eternal optimists who can even see
the possible good in AP.
  I suggested in a recent post that perhaps Green Peace could use
the AP system to drain the profit margins of whalers without
actually causing their death. Of course, I was low on Scotch at
the time, so my idea cannot be taken seriously.
--
Toto
"The Xenix Chainsaw Massacre"
http://bureau42.base.org/public/xenix/xenbody.html

{% endraw %}
```

## Thread

+ Return to [April 1997](/archive/1997/04)

+ Return to "[Toto <toto@sk.sympatico.ca>](/authors/toto_toto_at_sk_sympatico_ca_)"

+ _Unknown thread root_
  + 1997-04-08 (Mon, 7 Apr 1997 21:23:16 -0700 (PDT)) - Blanc Weber / Positivist Schill - _Toto<EMAIL_ADDRESS>


text:
---
author: Snipe
title:  Snipe
pcid: Snipe
layout: single
date:   2020-09-10 20:23:29 -0700
excerpt: Elf 1 (played by Fabien) Hommlet
header:
  teaser: /assets/images/PC-SnipePortrait-thumb.png
author_profile: true
---

{% assign pc = site.data.pcs[page.pcid] %}

### {{ pc.class }} {{ pc.level }}
**Current Location:** {{ pc.location }}
**Current XP:** {{ pc.xp }}

![Snipe (_Fabien_)](/assets/images/PC-Snipe.2020.09.03.jpg)

license: Unlicense

repository: errinlarsen/barrowmaze

gha_license_id: Unlicense

repo_name: errinlarsen/barrowmaze


text:
---
title: "New Ansible os-, ssh- and mysql-hardening releases"
date:   2017-04-23 13:00:00
authors:
- name: Sebastian Gumprich
  image: https://avatars0.githubusercontent.com/u/3198961?v=4
  link: https://www.zufallsheld.de
---

Hey friends,

We released new versions of [ansible-os-hardening](https://github.com/dev-sec/ansible-os-hardening), [ansible-ssh-hardening](https://github.com/dev-sec/ansible-ssh-hardening) and [ansible-mysql-hardening](https://github.com/dev-sec/ansible-mysql-hardening)!

These releases are important to us in multiple ways:

As always, they provide new features and configuration possibilities for you to use! More on that below.

# Complete tests in TravisCI

Furthermore we now leverage the full possibilities of [TravisCI](https://travis-ci.org/dev-sec/) for the [os-hardening](https://travis-ci.org/dev-sec/ansible-ssh-hardening), [ssh-hardening](https://travis-ci.org/dev-sec/ansible-ssh-hardening) and [mysql-hardening](https://travis-ci.org/dev-sec/ansible-mysql-hardening)  roles. This means that all supported operating systems are now tested and verified online. For that we use customized [docker-images](https://github.com/rndmh3ro/docker-ansible) that have Ansible pre-installed, as well as our [InSpec-tests](https://github.com/dev-sec/?utf8=%E2%9C%93&q=baseline&type=&language=) to verify the roles!

However some operating systems are still missing for mysql-hardening because we're facing some issues that hopefully will be resolved soon!

We're always looking for help! Join us on [GitHub](https://github.com/dev-sec/) or [Gitter chatroom](https://gitter.im/dev-sec/general).

# Breaking Changes

One more important thing to note are the **breaking changes**.

## All roles

We removed support for Ansible 1.9 in all three roles, so we can leverage the new modules and functions of Ansible 2.0!

## ssh-hardening

- Change the ssh_client_ports list variable into a simple non-list variable named ssh_client_port.  [\#84](https://github.com/dev-sec/ansible-ssh-hardening/pull/84) ([fullyint](https://github.com/fullyint))

Before:
```jinja
{% for port in ssh_client_ports -%}
Port {{port}}
{% endfor %}
```

After:
```jinja
Port {{ ssh_client_port }}
```

- Fix ssh config to handle custom options per Host [\#83](https://github.com/dev-sec/ansible-ssh-hardening/pull/83) ([fullyint](https://github.com/fullyint))

Before:
```jinja
    # one or more hosts, to which ssh-client can connect to.
# Default is empty, but should be configured for security reasons!
    ssh_remote_hosts: []           # ssh
```

After:
```jinja
# Hosts with custom options.            # ssh
# Example:
# ssh_remote_hosts:
#   - names: ['example.com', 'example2.com']
#     options: ['Port 2222', 'ForwardAgent yes']
#   - names: ['example3.com']
#     options: ['StrictHostKeyChecking no']
ssh_remote_hosts: []
```

## mysql-hardening

- Renamed variables in [\#22](https://github.com/dev-sec/ansible-mysql-hardening/pull/22) ([agno01](https://github.com/agno01)) and [\#26](https://github.com/dev-sec/ansible-mysql-hardening/pull/26)
  - renamed `mysql_hardening_mysql_conf` var to `mysql_hardening_mysql_conf_file`
  - introduced `mysql_hardening_mysql_conf_dir` variable
  - introduced `mysql_cnf_owner` as variable for owner of configuration files
  - set default value of `mysql_hardening_mysql_conf_dir` variable for RedHat, OracleLinux, Debian
  - changed default hardcoded full path in `mysql_hardening_hardening_conf` var to be based on `mysql_hardening_mysql_conf_dir` var

# Improvements

Of course we were productive in fixing bugs, improving the code and adding more features. All with the help of [our](https://github.com/dev-sec/ansible-os-hardening/graphs/contributors) [awesome](https://github.com/dev-sec/ansible-ssh-hardening/graphs/contributors) [contributors](https://github.com/dev-sec/ansible-mysql-hardening/graphs/contributors)!

## os-hardening

- Install initramfs-tools [\#114](https://github.com/dev-sec/ansible-os-hardening/pull/114) ([rndmh3ro](https://github.com/rndmh3ro))
- Omit empty variables [\#106](https://github.com/dev-sec/ansible-os-hardening/pull/106) ([rndmh3ro](https://github.com/rndmh3ro))

Full [Changelog](https://github.com/dev-sec/ansible-os-hardening/releases/tag/4.0.0)

## ssh-hardening
- Use different Hostkeys according to installed ssh version [\#99](https://github.com/dev-sec/ansible-ssh-hardening/pull/99) ([rndmh3ro](https://github.com/rndmh3ro))
- Remove small dh primes [\#97](https://github.com/dev-sec/ansible-ssh-hardening/pull/97) ([rndmh3ro](https://github.com/rndmh3ro))
- Add Ed25519 SSH host key to match ssh-baseline [\#96](https://github.com/dev-sec/ansible-ssh-hardening/pull/96) ([techraf](https://github.com/techraf))
- Add support for FreeBSD OpenSSH server and client [\#95](https://github.com/dev-sec/ansible-ssh-hardening/pull/95) ([jbenden](https://github.com/jbenden))
- Defaults: Remove DSA from SSH host keys to match ssh-baseline profile [\#92](https://github.com/dev-sec/ansible-ssh-hardening/pull/92) ([techraf](https://github.com/techraf))
- Make ChallengeResponseAuthentication configurable [\#85](https://github.com/dev-sec/ansible-ssh-hardening/pull/85) ([rndmh3ro](https://github.com/rndmh3ro))

Full [Changelog](https://github.com/dev-sec/ansible-ssh-hardening/releases/tag/4.0.0)

## mysql-hardening

- Add CentOS7 with MariaDB support [\#27](https://github.com/dev-sec/ansible-mysql-hardening/pull/27) ([chrispoupart](https://github.com/chrispoupart))
- Add follow=yes to my.cnf protect task, in case its a symlink. [\#21](https://github.com/dev-sec/ansible-mysql-hardening/pull/21) ([rndmh3ro](https://github.com/rndmh3ro))

Full [Changelog](https://github.com/dev-sec/ansible-mysql-hardening/releases/tag/2.0.0)

You can follow us on [Twitter](https://twitter.com/DevSecIO).

Thanks and have a nice and secure day!

Sebastian

branch_name: refs/heads/src

gha_language: SCSS


text:
# CONTRIBUTORS Guide

## How to get started?

The easiest way to start is to look at existing issues and see if there’s something there that you’d like to work on. You can filter issues with the label “[Good first issue](https://github.com/chefgs/terraform_repo/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)” which are relatively self sufficient issues and great for first time contributors.

Once you decide on an issue, please comment on it so that all of us know that you’re on it.

If you’re looking to add a new feature, [raise a new issue](https://github.com/chefgs/terraform_repo/issues/new) and start a discussion with the community. Engage with the maintainers of the project and work your way through.

You'll need to perform the following tasks in order to submit your changes:

- Fork the `terraform_repo` repository.
- Create a branch for your changes.
  - In case if you're picking up an issue, thenname your branch corresponds to an `issue_id`
- Add commits to that branch.
- Open a [PR](https://github.com/chefgs/terraform_repo/compare) and choose your `branch_name` to share your contribution.

## HERE’S WHAT YOU NEED TO KNOW TO PARTICIPATE AND COMPLETE HACKTOBERFEST:
- Register anytime between September 26 and October 31

- Pull requests can be made in any GITHUB (or GITLAB) hosted project that’s participating in Hacktoberfest (look for the “hacktoberfest” topic)

- Project maintainers must accept your pull/merge requests for them to count toward your total

- Have 4 pull/merge requests accepted between October 1 and October 31 to complete Hacktoberfest

- The first 40,000 participants (maintainers and contributors) who complete Hacktoberfest can elect to receive one of two prizes: a tree planted in their name, or the Hacktoberfest 2022 t-shirt.

- Your PR/MRs must be created between October 1 and October 31 (in any time zone, UTC-12 thru UTC+14).
- Your PR/MRs must be made to a public, unarchived repository.

### [ SPAM ]

- YOUR PR/MRS MUST NOT BE SPAMMY.
- PR/MRs that are labeled with a label containing the word “spam” by maintainers will not be counted.
  - PR/MRs that also have the “hacktoberfest-accepted” label cannot be marked as spammy via a label.
  - PR/MRs that have been merged and do not have a label containing the word “invalid” cannot be marked as spammy via a label.
  - PR/MRs that our system detects as spammy will also not be counted.
- Any user with two or more spammy PR/MRs will be disqualified.

### [ PARTICIPATING ]
- YOUR PR/MRS MUST BE IN A REPO TAGGED WITH THE “HACKTOBERFEST” TOPIC, OR HAVE THE “HACKTOBERFEST-ACCEPTED” LABEL.
- Hacktoberfest is now opt-in for maintainers, so only contribute to projects that indicate they’re looking for Hacktoberfest PR/MRs.
- Once your PR/MR has passed this check, we won’t check this again (unless your PR/MR fails a check before this, such as it being marked as spammy).

### [ INVALID ]
- YOUR PR/MRS MUST NOT BE LABELED AS “INVALID”.
- PR/MRs that have a label containing the word “invalid” won’t be counted, unless they also have the “hacktoberfest-accepted” label.
- Specifically, we use the Node.js 16 RegEx engine with /\binvalid\b/i to look for invalid labels.

### [ ACCEPTED ]
- YOUR PR/MRS MUST BE MERGED, HAVE THE “HACKTOBERFEST-ACCEPTED” LABEL, OR HAVE AN OVERALL APPROVING REVIEW.
- Your PR/MR must not be a draft to be considered accepted.
- If your PR/MR is being accepted for Hacktoberfest via an overall approving review it must also not be closed.
- ONCE YOUR PR/MRS PASS ALL THE CHECKS ABOVE, IT WILL BE ACCEPTED FOR HACKTOBERFEST AFTER THE 7-DAY REVIEW PERIOD.
- We continually evaluate all of the checks except the [PARTICIPATING] check. If it fails any of these checks during this time, the 7-day timer will reset.
- After the 7-day review period completes, your PR/MR will be automatically accepted for Hacktoberfest assuming it still passes all the checks. Once accepted for Hacktoberfest, we stop checking. :party:

gha_language: HCL


text:
---
user-guide-title: AEM Assets Essentials Videos
user-guide-description: A collection of videos for Adobe Experience Manager Assets Essentials.
breadcrumb-title: AEM Assets Essentials Videos
feature-set: Experience Manager Assets
team: TM
---

# AEM Assets Essentials Videos {#assets-essentials}

+ [Overview](overview.md)

+ [Provisioning](./provisioning.md)
+ [Getting started](./getting-started.md)

+ Basics{#basics}
  + [Managing](basics/managing.md)
  + [Using](basics/using.md)
  + [Creating content](basics/creating.md)
  + [Collaboration](basics/collaborating.md)

+ [Creative Cloud integration](integrations/creative-cloud.md)
+ [Adobe Journey Optimizer integration](https://experienceleague.adobe.com/docs/journey-optimizer-learn/tutorials/create-messages/create-email-content-with-the-message-editor.html)


text:
---
layout: post
title: "Bulk editing a large number of issues is slow in Jira"
subtitle:   "Bulk editing a large number of issues is slow in Jira"
date:       2023-02-27 2:20:00 +0800
author:     "Dongyupu"
header-img: "img/post-bg-01.jpg"
---
## [Bulk editing a large number of issues is slow in Jira](https://confluence.atlassian.com/jirakb/bulk-editing-a-large-number-of-issues-is-slow-in-jira-968669347.html)

Platform notice: Server and Data Center only. This article only applies to Atlassian products on the server and data center platforms.

### Problem
Bulk editing issues in Jira is slow. It can take anywhere from 10 minutes to a few hours to bulk edit a large amount of issues. Here are some sample bulk edit times tested on a new/vanilla JIRA server instance:

- We've tested editing issues to add a value to 3 fields and change the priority of all issues, and this is how long this took depending on the number of issues:

  - 100 issues - 7 seconds
  - 500 issues - 32 seconds
  - 1000 issues - 67 seconds
Depending on the changes you are making to all of these tickets, the times can vary. It is acceptable for this to take up to a few minutes. However, in the cases where this is taking too long and the changes are prohibitive, you might be able to speed this up.

### Diagnosis
- Check if this is only occurring in a 3rd party or custom field - if so, get in touch with the plugin vendor for support

- This issue has been encountered when using specific custom fields from the Xray Test Management plugin for Jira.
- Enable safe mode and see if the issue continues - if the issue goes away then this could be a plugin issue

- Run a background re-index and then test again
- Ensure you are not encountering any performance issues that could be causing this.
### Solution
- If safe mode helps speed this up, disable each 3rd party individually and test to narrow it down to a specific plugin

- If this is caused by a custom field coming from a 3rd party plugin, contact the plugin vendor for support

- If this is caused by a custom field you have set up, or if you are unable to resolve this otherwise - contact Atlassian Support

  - Do include logs with the com.atlassian.jira.web.action.issue.bulkedit package set to DEBUG logging to add the Bulk Edit progress percentage added in the log, visualizing the slowness of the operation

url: https://raw.githubusercontent.com/dongyupu/dongyupu.github.com/84a937f0afcc30513a9a6c46c16f00d883d03a72/_posts/jira/2023-02-27-Bulk editing a large number of issues is slow in Jira.md


text:
---
slug: mish-flexible-shell-notebooks
date: 2018-06-05T22:01:37.684Z
author: dan
layout: blog
canonical_url: "https://medium.com/windmill-engineering/mish-flexible-shell-notebooks-3d8a0e008716"
title: "mish: Flexible Shell Notebooks"
image_caption: "easier refining and repeating"
image: "1_w-2_vusBqdbQA_1oxcBFKw.gif"
image_needs_slug: true
tags:
  - terminal
keywords:
  - terminal
---

Shell makes it easy to rerun previous commands, but hard to edit them. Rerunning is `<up>-<enter>`, but editing requires `<up>-<left>-<left>-<backspace>-<wait-how-many-backspaces-was-it>-<etc.>`. If you’ve ever been irritated editing in shell, our [new tool `mish`](https://github.com/windmilleng/mish) can save you time and hassle.

`mish` is a terminal app that augments easy-rerun with a better editing experience: your existing editor. By storing data in a file (`notes.mill`)instead of as command-line arguments, `mish` lets you flex your muscle memory to tweak your workflow. Your cursor stays put; your keyboard shortcuts are familiar.

Your `notes.mill` file is your personal notebook. It’s scratch space; edit as frequently as you need to change an argument. It’s durable; you won’t lose tuned commands to the shell history limit. It’s organized; different workflows can be separated and organized.

You can get `[mish` from github](https://github.com/windmilleng/mish). In 5 minutes, you’ll have a better shell experience. Have fun! If you’re still here, I’ll give a quick tour of `mish`.

## Hello World

`mish` works best when you run two apps side-by-side: on the left, your editor with your code and a new file `notes.mill` in the root of your project. Open a terminal on the right and run `mish`.

`notes.mill` is written in Mill, a dialect of python (if you tell your editor that .mill files are python, you’ll get syntax highlighting, etc.). A good hello world is:

```
sh("ls")
sh("echo hello mish")
```

Switch into the `mish` window and hit `r` to rerun.

![selecting a workflow](/assets/images/mish-flexible-shell-notebooks/1_1iZGUcjmLf8mvYYjtU0ZLg.gif)*selecting a workflow*

## Workflows

Sometimes I want to run unittests; other times I want to start a server. Mill supports this by letting you define workflows:

```
def wf_hello():
  sh("ls")
  sh("echo hello mish")

def wf_serve():
  sh("./server/main.py") # run the server
```

Now pressing `r` will reload the Mill file, but the interesting workflows are in functions. Hit `f` to list available workflows, and pick one to focus on.

## Refine

My magic moment with `mish`, when it became an indispensable tool, is when I’m modifying command lines. I end up with a section like:

```
def wf_scratch():
  sh("go test -run TestWatchOneFile$ ./os/watch") # run one test
  sh("go test ./os/watch") # run all tests in the watch package
  sh("go test ./...") # run all tests in the project
```

Because `mish` will error after a failing command, this helps me iterate while I’m seeing red, until everything passes and I’m seeing green.

## Mish your way

What will make `mish` click for you? Maybe it’s the way it can take fewer keystrokes to restart a server. Or making sure you generate code as you’re editing your protocol buffers. But we’re pretty sure the next time you’re editing a command in shell, you’ll have a better day if you [try `mish`](https://github.com/windmilleng/mish).

Make sure to let us know by filling out our [5-minute survey](https://docs.google.com/forms/d/e/1FAIpQLSf8UXLG0FOeMswoW7LuUP02CeUwKBccJishJKDE_VyOqe7g_g/viewform?usp=sf_link).

![](/assets/images/mish-flexible-shell-notebooks/1_KbCt7S4W2Eh8EK7mqor4Pg.png)


text:
# Network Messages

For the most part we recommend the high level [Commands and RPC](RemoteActions.md) calls and [SyncVar](../StateSync.md), but you can also send low level network messages.  This can be useful if you want clients to send messages that are not tied to gameobjects, such as logging, analytics or profiling information.

There is a class called MessageBase that you can extend to make serializable network message classes. This class has Serialize and Deserialize functions that take writer and reader objects. You can implement these functions yourself, but we recommend you let Mirror generate them for you.

The base class looks like this:

```cs
public abstract class MessageBase
{
    // Deserialize the contents of the reader into this message
    public virtual void Deserialize(NetworkReader reader) {}

    // Serialize the contents of this message into the writer
    public virtual void Serialize(NetworkWriter writer) {}
}
```

The auto generated Serialize/Deserialize can efficiently deal with basic types, structs, arrays and common Unity value types such as Color, Vector3, Quaternion. Make your members public. If you need class members or complex containers such as List and Dictionary, you must implement the Serialize and Deserialize methods yourself.

To send a message, use the `Send()` method on the NetworkClient, NetworkServer, and NetworkConnection classes which work the same way. It takes a message object that is derived from MessageBase. The code below demonstrates how to send and handle a message:

To declare a custom network message class and use it:

```cs
using UnityEngine;
using Mirror;

public class Scores : MonoBehaviour
{
    NetworkClient myClient;

    public class ScoreMessage : MessageBase
    {
        public int score;
        public Vector3 scorePos;
        public int lives;
    }

    public void SendScore(int score, Vector3 scorePos, int lives)
    {
        ScoreMessage msg = new ScoreMessage()
        {
            score = score,
            scorePos = scorePos,
            lives = lives
        };

        NetworkServer.SendToAll(msg);
    }

    // Create a client and connect to the server port
    public void SetupClient()
    {
        myClient = new NetworkClient();
        myClient.RegisterHandler<ScoreMessage>(OnScore);
        myClient.Connect("<IP_ADDRESS>", 4444);
    }

    public void OnScore(ScoreMessage msg)
    {
        Debug.Log("OnScoreMessage " + msg.score);
    }
}
```

Note that there is no serialization code for the `ScoreMessage` class in this source code example. The body of the serialization functions is automatically generated for this class by Mirror.

## ErrorMessage Class

There is also an ErrorMessage class that is derived from `MessageBase`. This class is passed to error callbacks on clients and servers.

The errorCode in the ErrorMessage class corresponds to the Networking.NetworkError enumeration.

```cs
class MyClient
{
    NetworkClient client;

    void Start()
    {
        client = new NetworkClient();
        client.RegisterHandler<ErrorMessage>(OnError);
    }

    void OnError(ErrorMessage errorMsg)
    {
        Debug.Log("Error:" + errorMsg.errorCode);
    }
}
```

gha_license_id: NOASSERTION


text:
# Sebacina calospora (Bourdot & Galzin) Bourdot & Galzin, 1928 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Hyménomyc. de France 46 (1928)

#### Original name
Exidiopsis calospora Bourdot & Galzin, 1924

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Auriculariales/Ceratosebacina/Ceratosebacina calospora/ Syn. Sebacina calospora/README.md

repo_name: mdoering/backbone


text:
# loono

We show prevention matters.

- To generate the freezed or db part files run `flutter packages pub run build_runner build --delete-conflicting-outputs`.
- If you need to define anything non static on a freezed class remember to add a private constructor (https://pub.dev/packages/freezed#custom-getters-and-methods)
- You might need to rerun the Dart Analyser for the IDE to be pick up the generated files

Notes

- We are committing generated files to avoid situations where those files might be different among
  developers or might differ from the ones generated via the CodeMagic pipeline. We also commit them to
  avoid spending time and money when building the app on CodeMagic.

## App internalizations

- Currently app supports only Czech language, all texts used within the app should be located in `lib/l10n/intl_cs.arb`. Supporting new languages can be made by adding new language arb file.
- Internalization is done by [flutter_internalization](https://flutter.dev/docs/development/accessibility-and-localization/internationalization) plugin


text:
---
layout: post
title: Lauren and Gems and Miro
---

Lauren moderated today, and brought the topic of harvesting "Gems"
from conversations.  (That's my understanding, but I'm willing to be
corrected.)

Welcome to Kayla Ancheta Chey, whom I met for the first time today,
though she says she's attended a couple previous GCC sessions.

Also, welcome back, Charles! Haven't seen you in a while :)

I don't know anything about Miro other than what Lauren presented
today, but it looked easy to use, and likely useful.  So I signed up
with FB SSO at miro.com. Here's an [invitation
link](https://miro.com/welcome/yLFy5R02aMoUUxefUd4PLUj5PFmRhkka6Ysyhw50gMENfGHGsosOlsmLYMRviZTy
) to join the GCC "real time board" at Miro.

[![Example of Miro from Lauren](/images/2020/ScreenShot-Miro-Lauren.png)](https://miro.com/welcome/yLFy5R02aMoUUxefUd4PLUj5PFmRhkka6Ysyhw50gMENfGHGsosOlsmLYMRviZTy)

> It appears that Lauren extracted some quotes / gems from [20200104
  Barn Raising](https://youtu.be/odskUenl2l0)

re: "hitting a button" in real-time to record a gem: I think this is a
nice option / feature, but I would have to train myself to use
it. Culturally, some of us (I include myself) aren't prone to
"self-promotion" of the kind to say "What I'm about to say is a
**gem**, so it merits special-marking".

Frankly, if I don't think what I'm about to say is relevant and
significant, and worth noting, I'm likely to stay silent. So in one
sense, every time I speak, I'd in some sense want to hit the "gem"
button.

<hr/>

Next up, we have:
* Jaswinder, May 23
* Charles, May 30
* Joshua, Jun 6

Kayla said she would likely take a future session, and I'm also on
deck at some point.

More later...