text:
# Interface: ZipInputFile

A stream that can be used to create a file in a ZIP archive

## Hierarchy

- [`ZipAttributes`](ZipAttributes.md)

  ↳ **`ZipInputFile`**

## Implemented by

- [`AsyncZipDeflate`](../classes/AsyncZipDeflate.md)
- [`ZipDeflate`](../classes/ZipDeflate.md)
- [`ZipPassThrough`](../classes/ZipPassThrough.md)

## Table of contents

### Properties

- [attrs](ZipInputFile.md#attrs)
- [comment](ZipInputFile.md#comment)
- [compression](ZipInputFile.md#compression)
- [crc](ZipInputFile.md#crc)
- [extra](ZipInputFile.md#extra)
- [filename](ZipInputFile.md#filename)
- [flag](ZipInputFile.md#flag)
- [mtime](ZipInputFile.md#mtime)
- [ondata](ZipInputFile.md#ondata)
- [os](ZipInputFile.md#os)
- [size](ZipInputFile.md#size)
- [terminate](ZipInputFile.md#terminate)

## Properties

### attrs

• `Optional` **attrs**: `number`

The file's attributes. These are traditionally somewhat complicated
and platform-dependent, so using them is scarcely necessary. However,
here is a representation of what this is, bit by bit:

`TTTTugtrwxrwxrwx0000000000ADVSHR`

TTTT = file type (rarely useful)

u = setuid, g = setgid, t = sticky

rwx = user permissions, rwx = group permissions, rwx = other permissions

0000000000 = unused

A = archive, D = directory, V = volume label, S = system file, H = hidden, R = read-only

If you want to set the Unix permissions, for instance, just bit shift by 16, e.g. 0o644 << 16.
Note that attributes usually only work in conjunction with the `os` setting: you must use
`os` = 3 (Unix) if you want to set Unix permissions

#### Inherited from

[ZipAttributes](ZipAttributes.md).[attrs](ZipAttributes.md#attrs)

___

### comment

• `Optional` **comment**: `string`

The comment to attach to the file. This field is defined by PKZIP's APPNOTE.txt,
section 4.4.26. The comment must be at most 65,535 bytes long UTF-8 encoded. This
field is not read by consumer software.

#### Inherited from

[ZipAttributes](ZipAttributes.md).[comment](ZipAttributes.md#comment)

___

### compression

• **compression**: `number`

The compression format for the data stream. This number is determined by
the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no
compression, 8 = deflate, 14 = LZMA

___

### crc

• **crc**: `number`

A CRC of the original file contents. This attribute may be invalid after
the file is added to the ZIP archive; it must be correct only before the
stream completes.

If you don't want to have to generate this yourself, consider extending the
ZipPassThrough class and overriding its process() method, or using one of
ZipDeflate or AsyncZipDeflate.

___

### extra

• `Optional` **extra**: `Record`<`number`, `Uint8Array`\>

Extra metadata to add to the file. This field is defined by PKZIP's APPNOTE.txt,
section 4.4.28. At most 65,535 bytes may be used in each ID. The ID must be an
integer between 0 and 65,535, inclusive.

This field is incredibly rare and almost never needed except for compliance with
proprietary standards and software.

#### Inherited from

[ZipAttributes](ZipAttributes.md).[extra](ZipAttributes.md#extra)

___

### filename

• **filename**: `string`

The filename to associate with the data provided to this stream. If you
want a file in a subdirectory, use forward slashes as a separator (e.g.
`directory/filename.ext`). This will still work on Windows.

___

### flag

• `Optional` **flag**: `number`

Bits 1 and 2 of the general purpose bit flag, specified in PKZIP's
APPNOTE.txt, section 4.4.4. Should be between 0 and 3. This is unlikely
to be necessary.

___

### mtime

• `Optional` **mtime**: `string` \| `number` \| `Date`

When the file was last modified. Defaults to the current time.

#### Inherited from

[ZipAttributes](ZipAttributes.md).[mtime](ZipAttributes.md#mtime)

___

### ondata

• `Optional` **ondata**: [`AsyncFlateStreamHandler`](../README.md#asyncflatestreamhandler)

The handler to be called when data is added. After passing this stream to
the ZIP file object, this handler will always be defined. To call it:

`stream.ondata(error, chunk, final)`

error = any error that occurred (null if there was no error)

chunk = a Uint8Array of the data that was added (null if there was an
error)

final = boolean, whether this is the final chunk in the stream

___

### os

• `Optional` **os**: `number`

The operating system of origin for this file. The value is defined
by PKZIP's APPNOTE.txt, section <IP_ADDRESS>. For example, 0 (the default)
is MS/DOS, 3 is Unix, 19 is macOS.

#### Inherited from

[ZipAttributes](ZipAttributes.md).[os](ZipAttributes.md#os)

___

### size

• **size**: `number`

The size of the file in bytes. This attribute may be invalid after
the file is added to the ZIP archive; it must be correct only before the
stream completes.

If you don't want to have to compute this yourself, consider extending the
ZipPassThrough class and overriding its process() method, or using one of
ZipDeflate or AsyncZipDeflate.

___

### terminate

• `Optional` **terminate**: [`AsyncTerminable`](AsyncTerminable.md)

A method called when the stream is no longer needed, for clean-up
purposes. This will not always be called after the stream completes,
so you may wish to call this.terminate() after the final chunk is
processed if you have clean-up logic.

gha_language: TypeScript


text:
---
title: web-animations-api-waapi-blog
tags: [animation, waapi, web]
created: 2020-08-03T06:38:58.197Z
modified: 2021-09-22T04:14:11.396Z
---

# web-animations-api-waapi-blog

# Web Animations API Tutorial Series

- ## [Let’s talk about the Web Animations API_Dan Wilson](http://danielcwilson.com/blog/2015/07/animations-intro/)
  - This is an introduction to a tutorial series on the Web Animations API coming to browsers.
  - That wasn’t implemented yet (you’ll find out what happened in Part 5), but its goal of providing a way to unite the CSS, JS, and SVG ways to animate kept me interested.
  - CSS has hardware acceleration for smooth transitions and support is built into the browser,
    - but rules are declared in CSS and require jumping through JavaScript hoops to get values dynamically changed.
  - `requestAnimationFrame` has good support and lets the browser optimize when to animate,
    - but it can still hang up if there is a lot of other JavaScript running.
    - It also often requires more math to get timing down.
  - `setInterval` introduced many developers to animations,
    - but it is imprecise and can lead to stuttering animations.
  - `jQuery.animate()` introduced several other developers to animations, but often has performance issues.
  - Libraries such as Velocity and GreenSock (GSAP) improve JavaScript performance and have been tested in many situations to be the best they can be.
    - They still, however, require maintaining and loading external libraries.
  - In general, we like it when browsers support as much as they can, and they take over the optimizations.
    - Browsers now have `document.querySelector` because we saw the value jQuery provided to select DOM elements.
    - So utilities in libraries moved into the browser natively.
    - Ideally, we could pack as much animation control at the browser level.
    - These libraries can then focus on providing newer features, and the cycle can continue.
  - The Web Animations API tries to do this.
    - It aims to bring the power of CSS performance, add the benefits and flexibility of JavaScript (and SVG animation, which we will talk about in a future post), and leave it to the browsers to make it work well.
    - The syntax is similar to CSS but adds the options of variables, controls, and finish callbacks.

- ## [Web Animations API Tutorial Part 1: Creating a Basic Animation](http://danielcwilson.com/blog/2015/07/animations-part-1/)
- ## [Web Animations API Tutorial Part 2: The Animation & Timeline Controls](http://danielcwilson.com/blog/2015/07/animations-part-2/)
- ## [Web Animations API Tutorial Part 3: Multiple Animations](http://danielcwilson.com/blog/2015/08/animations-part-3/)
- ## [Web Animations API Tutorial Part 4: GroupEffects & SequenceEffects](http://danielcwilson.com/blog/2015/09/animations-part-4/)
- ## [Web Animations API Tutorial Part 5: The Loveable Motion Path](http://danielcwilson.com/blog/2015/09/animations-part-5/)

- ## [Web Animations API Tutorial Conclusion](http://danielcwilson.com/blog/2015/09/animations-conclusion/)
  - The spec, browser implementations, and polyfill have been going on for a while, and they are ready to examine closely.

- ## [When to Use the Web Animations API_201608](http://danielcwilson.com/blog/2016/08/why-waapi/)
  - I still typically prefer CSS for animating.
    - You state an animation once, and all matching selectors will pick up on it without you having to iterate through them all.
    - There’s a reason over time we’ve seen things move from JS to CSS, and for me it’s hard to beat declaring some rules in CSS and calling it a day.
  - So Why Go with the API?
    - Dynamic/Random/New Values
    - A Plethora of Class Toggles
    - Playback Control
    - Chaining Multiple Animations
  - The Web Animations spec that underlies the Web Animations API is all about uniting JS and CSS methods.

- ## [3 Ways to Use Independent Transform Properties](http://danielcwilson.com/blog/2017/10/all-the-transform-ways/)
- ## [Additive Animation with the Web Animations API](http://danielcwilson.com/blog/2018/01/additive-animation/)

- ## [CSS + the Web Animations API_202004](http://danielcwilson.com/blog/2020/04/css-in-the-waapi/)
  - While the Web Animations API initially brought a similar mechanism as CSS animations to JavaScript, it also added a few additional features like modifying playback rate and jumping to different points in an animation’s timeline.
  - As the final pieces of the Web Animations Level 1 specification roll out to browsers, it’s not just JavaScript that gets extra features.
  - Getting all Web Animations with the API
    - One of the newer pieces now available is the ability to get references to all the animations for a specific element or even a full document.
    - `document.getAnimations();`
    - The best part is that this new Web Animations API method does not just return animations that were created with the Web Animations API, but also CSS Animations and CSS Transitions.
    - Any API method can then be called on the CSS animations and transitions as though it had been created by the API.
  - How do I know where an animation was created?
    - Each animation that appears in the `getAnimations()` array today will be of type `Animation` , `CSSAnimation` , or `CSSTransition` .
    - This means each type will have the normal Web Animations API methods, but the two CSS ones will have an extra property that are specific to those needs.
      - animationName, transitionProperty
    - If you need to know which WAAPI animation is which, you can look at the keyframes or timing options, or specify an `id` at creation which is returned back.
  - Extending CSS Animations with the Web Animations API
    - Since all these animations share a common interface and have the same underlying engine behind them (one of the main goals of the Web Animations specification), we can now use the API to interact with our CSS animations.
  - CSS animations and transitions have long had solid JavaScript event listeners for `animationend` , `transitionstart` , and others, so the Web Animations API does not bring much new here. That said, the WAAPI offers comparable callbacks and Promises if those are preferred.

# Web Animations in Safari 13.1

- [webkit: Web Animations in Safari 13.1_202004](https://webkit.org/blog/10266/web-animations-in-safari-13-1/)

- With the release of iOS 13.4, iPadOS 13.4, and Safari 13.1 in macOS Catalina 10.15.4, web developers have a new API at their disposal: Web Animations.
- As a web developer, I’ve enjoyed the simplicity and great performance of CSS Animations and CSS Transitions.
- However, in my day-to-day work, I also found a few areas where these technologies were frustrating: dynamic creation, playback control, and monitoring an animation’s lifecycle.
- The great news is that these issues are all taken care of by the new Web Animations API

- Animation Creation
  - While CSS allows you to very easily animate a state change (the appearance of a button, for instance), it will be a lot trickier if the start and end values of a given animation are not known ahead of time.
  - Forcing a style invalidation will not let the browser perform that task at the time it will judge most appropriate.
  - And if you consider using CSS Animations instead, you would have to first generate a dedicated `@keyframes` rule and insert it inside a `<style>` element, failing to encapsulate what is really a targeted style change for a single element and causing a costly style invalidation.

``` JS
// Set the transition properties and start value.
element.style.transitionProperty = "transform";
element.style.transitionDuration = "1s";
element.style.transform = "translateX(0)";

// Force a style invalidation such that the start value is recorded.
window.getComputedStyle(element);

// Now, set the end value.
element.style.transform = "translateX(100px)";
```

- The value of the Web Animations API lies in having a JavaScript API that preserves the ability to let the browser engine do the heavy lifting of running animations efficiently while enabling more advanced control of your animations.
- Now the browser will be able to process all new animations at the next most opportune moment with no need to force a style invalidation.
  - This means that animations you author yourself as well as animations that may originate from a third-party JavaScript library – or even in a different document (for instance, via an `<iframe>` ) – will all be started and progress in sync.

- Playback Control
  - While the `animation-play-state` property allows control of whether a CSS Animation is paused or playing, there is no equivalent for CSS Transitions and it only controls one aspect of playback control.
  - If you want to set the current time of an animation, you can only resort to roundabout techniques such as clever manipulations of negative animation-delay values, and if you want to change the speed at which an animation plays, the only option is to manipulate the timing values.
  - WAAPI gives developers control over the behavior of animations after they have been created.

- Animation Lifecycle
  - While the `transition*` and `animation*` family of DOM events provide information about when CSS-originated animations start and end, it is difficult to use them correctly.
  - Using the Web Animations API, writing this kind of code is not just easier but safer because you have a direct reference to an `Animation` object rather than working through animation events scoped to an element’s hierarchy.

- Web Animations are not designed to replace existing technologies but rather to tightly integrate with them.
  - You are free to use whichever technology you feel fits your use case and preferences best.
- The Web Animations specification does not just define an API but also aims to provide a shared model for animations on the web;
  - other specifications dealing with animations are defined with the same model and terminology.
  - As such, it’s best to understand Web Animations as the foundation for animations on the web, and think of its API as well as CSS Transitions and CSS Animations as layers above that shared foundation.

- To make a great implementation of the Web Animations API, we had to start off fresh with a brand new and shared animation engine for CSS Animations, CSS Transitions, and the new Web Animations API.
  - Even if you don’t use the Web Animations API, the CSS Animations and CSS Transitions you’ve authored are now running in the new Web Animations engine.
  - No matter which technology you choose, the animations will all run and update in sync, events dispatched by CSS-originated animation and the Web Animations API will be delivered together, etc.
  - But what may matter even more to authors is that the entire Web Animations API is available to query and control CSS-originated animations!
  - You can specify animations in pure CSS but also control them with the Web Animations APIs using `Document.getAnimations()` and `Element.getAnimations()` .

- At this stage, SVG Animations remain distinct from the Web Animations model, and there is no integration between the Web Animations API and SVG.
  - This remains an area of improvement for the Web platform.

- Shipping support for Web Animations is an important milestone for animations in WebKit.
  - Our new animation engine provides a more spec-compliant and forward-looking codebase to improve on.

# Web Animations in WebKit

- [Web Animations in WebKit_201806](https://webkit.org/blog/8343/web-animations-in-webkit/)

- Browser engines have supported various animation features for many years, CSS Transitions and CSS Animations being two widely-supported approaches to authoring efficient animations on the Web.
- While these features have proven popular, they become limited when developers try to integrate browser-implemented animations via JavaScript:
  - Creating a CSS Transition dynamically requires forcing or waiting for a style invalidation(失效) so start and end values can be specified
  - Creating CSS Animations dynamically requires `@keyframe` rules to be generated and inserted in a global stylesheet
  - Animations created via CSS are not represented via JavaScript and cannot be queried or controlled
- The value of Web Animations lies in having a JavaScript API that preserves the ability to let the browser engine do the heavy lifting of running animations efficiently while enabling more advanced control of your animations.
- The Web Animations specification goes further than specifying a JavaScript API.
  - It provides a timing and animation model for web browsers to implement features such as CSS Transitions and CSS Animations.
  - In fact, in WebKit, we’ve updated our implementation of these existing CSS technologies so that the same CSS Transitions and Animations you’ve been authoring for years are now represented as Web Animations objects in the browser.
  - Using the `getAnimations()` method, you can obtain a reference to a `CSSTransition` or `CSSAnimation` object which are `Animation` subclasses.
  - Then you can seek or pause a CSS transition running on an element just like we did above with an animation created using `element.animate()` .
  - As a developer, you can think of CSS Transitions and Animations as a declarative layer above Web Animations.

# Web Animations API improvements in Chromium 84

- [Web Animations API improvements in Chromium 84_202005](https://web.dev/web-animations/)

- Orchestrating animations with promises, performance improvements with replaceable animations, smoother animations with composite modes, and more.

- The Web Animations API is a tool that enables developers to write imperative animations with JavaScript.
- It was written to underpin(巩固，构成sth的基础) both CSS animation and transition implementations and enable future effects to be developed, as well as existing effects to be composed and timed.

！[The long history of the Web Animations API](https://webdev.imgix.net/web-animations/waapi-timeline.png)

- Creating an animation via the Web Animations API should feel very familiar if you've used `@keyframe` rules
- The amount of code is about the same, but with JavaScript, you get a couple of superpowers that you don't have with CSS alone. This includes the ability to sequence effects, and an increased control of their play states.
- Example: Dynamic interactions with partial keyframes
- When creating animations based on events, such as on `mousemove` , a new animation is created each time, which can quickly consume memory and degrade performance.
  - To address this problem, **replaceable animations** were introduced in Chromium 83, enabling automated cleanup, where finished animations are flagged as replaceable and automatically removed if replaced by another finished animation.

# Web Animations API Now Supported in All Evergreen Browsers

- [Web Animations API Now Supported in All Evergreen Browsers](https://www.infoq.com/news/2020/06/web-animations-evergreen-browser/)

- With the release of Safari 13.1, the Web Animations API now ships with all evergreen browsers.
- Early animations in web browsers were typically created with JavaScript APIs.
  - This approach was flexible but could not easily allow browsers to optimize animations with hardware acceleration or hooks into the layout and rendering pipeline.
- CSS Animations and CSS Transitions were first introduced by the WebKit team in 2007 and eventually became web standards.
  - These APIs are easy to use and overcome the challenges of early JavaScript animation implementations.
- However, CSS animations and transitions have known limitations, particularly around the dynamic creation of animations, controlling the playback of animations, and monitoring the lifecycle of an animation.
- The Web Animations API introduces a solution that gives the optimization power of CSS animations and transitions, but the flexibility of earlier JavaScript-based APIs.
- The Web Animations specification provides a shared model for animations on the web. CSS Transitions and CSS Animations exist as layers above that shared foundational model.

# ref

- [Exploring the Web Animations API_202001](https://www.javascriptjanuary.com/blog/exploring-web-animations-api)
  - In terms of performance, I haven't been able to see much difference between using CSS animations and the Web Animations API but that could be because my example is pretty small.
  - From what I understand, one big advantage is that, compared to other ways of animating using JavaScript, the WAAPI runs on the compositor, so we're letting the main thread forget about animations and deal with the rest of our code.
- [Animating like you just don’t care with Element.animate](https://hacks.mozilla.org/2016/08/animating-like-you-just-dont-care-with-element-animate/)
  - With the release of Firefox 48, `Element.animate()` is implemented in release versions of both Firefox and Chrome.
    - Furthermore, there’s a polyfill( `web-animations.min.js` ) that will fall back to using `requestAnimationFrame` for browsers that don’t yet support Element.animate().
    - In fact, if you’re using a framework like Polymer, you might already be using it!
  - Of course, you can get the same effect by using CSS Animations and CSS Transitions — in fact, in browsers that support Web Animations, the same engine is also used to drive CSS Animations and Transitions — but for some applications, script is a better fit.

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
## [/Examples/Conari](https://github.com/3F/Examples/tree/master/Conari)

This directory contains complete examples for [Conari](https://github.com/3F/Conari) project:

* [https://github.com/3F/Conari](https://github.com/3F/Conari)

Please note, **Conari** project provides documentation:

* Wiki: [https://github.com/3F/Conari/wiki](https://github.com/3F/Conari/wiki)

Screencasts:

* [Basic examples for C++ and C#](https://www.youtube.com/watch?v=9Hyg3_WE9Ks)
* [Complex types and Strings](https://www.youtube.com/watch?v=QXMj9-8XJnY)

## Complete Examples

...

repository: DaxxTrias/Examples

branch_name: refs/heads/master

repo_name: DaxxTrias/Examples


text:
# Twitch notification system for Arduino

This script takes the specified Twitch user's followed channels, and notifies the user through an LCD screen connected to an Arduino if a channel goes live.

Written in **Python 3**.

Before running the script, make sure to fill in the required fields in the config.py file:
* **CLIENT_ID** *string* The client ID for your application. You can get one [here](https://dev.twitch.tv/dashboard/apps/create).
* **OAUTH_ID** *string* Your OAuth token.
* **USERNAME** *string* Your Twitch username.
* **SERIAL_PORT** *string* The serial port the Arduino is connected to.
* **BAUD_RATE** *integer* Baud rate of the serial communication for the Arduino.
* **TIMEOUT** *integer* Timeout value for the serial port.
* **INTERVAL** *integer* Check interval in seconds.

## Hardware
* Arduino-compatible board
* 16x2 LCD Display based on the Hitachi HD44780 driver

Wiring and sample code can be found [here](https://www.arduino.cc/en/Tutorial/LiquidCrystalDisplay).
#### Additional notes
* Two pushbuttons connected to pins 22 and 23 in pullup mode
* Pin 15 (backlight anode) of the LCD connected to pin 8 through a 320 ohm resistor

The pushbuttons can be removed as they do not directly affect the functionality of the script, however, I highly recommend keeping one in as it is used to clear the display. If you choose to remove the other one (which essentially just toggles the backlight), you will not need the Bounce2 library.

## Arduino libraries
* Built-in LCD library
* [Bounce2](https://github.com/thomasfredericks/Bounce2)

## Python dependencies
* [pyserial](https://github.com/pyserial/pyserial)
* [python-twitch-client](https://github.com/tsifrer/python-twitch-client)

### Disclaimer
This is my first real Python project, and as such the code is probably horribly inefficient. Any suggestions, feedback and questions are welcome and appreciated.

repository: brajenful/twitch-arduino

repo_name: brajenful/twitch-arduino


text:
---
title: Events
---

### RECON gathering

These events are larger meetings aimed at fostering exchanges within the
community, drawing a snapshot of state-of-the-art epidemic analysis tools,
discussing recent outbreak response challenges as well as future directions
taken by our field, and creating new projects.

- [RECON gathering 1](https://recon-gathering-march2018.netlify.com/) (2018,
  London): *Challenges and Opportunities in Outbreak Response Analytics*; this
  event includes a one-day symposium followed by a day of workshops with 2
  parallel sessions: i) a discussion of analytic resources for field
  epidemiology training, and ii) a community-driven hackathon.

### RECON Hackfests

RECON Hackfests continue the process initiated during the Hackout events:
bringing people together to make new advances in the development of tools for
outbreak response.

- [Hackfest 1](http://www.repidemicsconsortium.org/hackfest1/) (2017, London):
  *making outbreak analysis easier and prettier*

- [Hackfest 2](http://www.repidemicsconsortium.org/hackfest2/) (2017, London):
  *mapping epidemics*

### The Hackouts series

RECON has been created in the aftermath of *Hackouts* 1, 2, and 3, a series of Hackathons for infectious disease outbreak analysis. To know more about these events, follow any of the links below:

- [Hackout 1](https://sites.google.com/site/hackoutwiki/home) (2013, London): *a hackathon for outbreak analysis using R*

- [Hackout 2: G.R.I.N.D.E.R.](https://sites.google.com/site/hackout2/) (2015, London): *Graphical Resources for Infectious Disease Epidemiology in R*

- [Hackout 3](http://hackout3.ropensci.org/) (2016, Berkeley): *analysis and modelling tools for emergency outbreak response*


text:
# learn.forge.designautomation - 3ds Max

To use Design Automation in general, the following steps are needed:

1. Create the appbundle and test it locally;
2. Upload the appbundle to the cloud;
2. Create the activity;
3. Create the work item (or more);
4. Start the job and download the results;

## 1. Create the appbundle and test it locally
In Design Automation, a bundle is the container that could hold custom code, plugin, scripts and any other content that is needed during every workitem execution.

The appbundle is a zip archived folder and should finish with `.bundle`.

> Example: myFiles.bundle

Inside this folder, the first thing that should be present is ` PackageContents.xml`, which describes to the used engine (g.e. 3ds Max) what to load on startup. For more documentation on this xml file check [here](https://help.autodesk.com/view/3DSMAX/2019/ENU/?guid=__developer_writing_plug_ins_packaging_plugins_packagexml_format_html).

> Example: A very simple containing a 3ds Max plugin written using 3ds Max .Net SDK, could be placed inside the bundle like this:

>![](./img/bundle_content.png)

> and the minimal amount of specification needed inside ` PackageContents.xml` could be the following:

>	```xml
>
>	<?xml version="1.0" encoding="utf-8"?>
>	<ApplicationPackage
>		AutodeskProduct="3ds Max"
>		ProductType="Application"
>		ProductCode="3ds Max Explode geometry plug-in.">
>
>		<CompanyDetails />
>
>		<Components Description="pre-start-up plugin part">
>			<RuntimeRequirements
>						OS="Win64"
>						Platform="3ds Max"
>						SeriesMin="2017"
>						SeriesMax="2019" />
>			<ComponentEntry
>					AppName="ADNExplodeGeometry"
>					Version="2.1.0"
>					ModuleName="./Contents/ManagedAssemblies/2017/ADNExplodeGeometry.dll" />
>		</Components>
>
>	```

**Note:** The above xml is just the minimum necessary, the schema for the ` PackageContents.xml` can accept a lot of information. For the full list, check [here](https://help.autodesk.com/view/3DSMAX/2019/ENU/?guid=__developer_writing_plug_ins_packaging_plugins_packagexml_format_html).

### Testing the appbundle locally

Before using the appbundle in Design Automation workflow, it is a good practice to test it locally. For this purpose, you can use `3dsmaxbatch.exe` located in the root of the 3ds Max installation folder:

![](./img/exec.png)

**Tip:** Note the use of environment variable to specify the 3ds installation folder. To get these environment variables, just type in Command Line `set ADSK`:

![](./img/env.png)

The workflow of using the `3dsmaxbatch.exe` is based on passing to it an execution script and the scene file to work with.
If needed, there is also the option of passing arguments for values (numbers) and strings.To understand the use of `3dsmaxbatch.exe`, please consult [Using 3ds Max Batch](https://knowledge.autodesk.com/support/3ds-max/learn-explore/caas/CloudHelp/cloudhelp/2019/ENU/3DSMax-Batch/files/GUID-48A78515-C24B-4E46-AC5F-884FBCF40D59-htm.html).

The simplest use of `3dsmaxbatch.exe` is passing a script (let us call it work script) and the scene file `3dsmaxbatch.exe myScript.ms -sceneFile myMaxFile.max`:

![](./img/local_test.png)

The complexity of the script file can vary and either contain the MAXScript code to do some operation on the file, or invoke plugin operations.

In case the work script is invoking plugin operations, we must make sure that before the 3ds max is running, the needed plugin was located and loaded.

3ds Max has special location for plugins, but in our case we are more interested in ways of informing 3ds Max of our custom location of the self contained plugin.

The bundle format is assuring that the plugin is self-contained and will be picked up by the 3ds Max and properly installed. The location of the bundle can be specified to 3ds Max by setting the `ADSK_APPLICATION_PLUGINS` environment variable:

![](./img/bundle_location.png)

> Example: Suppose that you create a MAXScript script (or C++, .Net plugin) that exposes just a simple function of listing the objects and saving the results into `list.txt` file:
>
> ```sql
> fn ListMyObject =
>(
>	dir = sysInfo.currentdir + "/list.txt"
>	f = (createFile dir)
>	allObjects = $*
>	for OBJ in allObjects do(
>		val1 = OBJ as string
>		val1 += "\n"
>		format val1 to:f
>	)
>)
>```
> we can create a folder with the following structure
>
> ![](./img/my_plugin_content.png)
>
> where the `PackageContents.xml` will have following content:
>
> ```xml
> <?xml version="1.0" encoding="utf-8"?>
><ApplicationPackage
>					SchemaVersion="1.0"
>					AutodeskProduct="3ds Max"
>					ProductType="Application"
>					ProductCode="3ds Max Design Share Plugin">
><CompanyDetails />
>	<Components Description="pre-start-up scripts parts">
>		<RuntimeRequirements
>				OS="Win64"
>				Platform="3ds Max"
>				SeriesMin="2018"
>				SeriesMax="2019" />
>		<ComponentEntry
>				AppName="ListMyObjects"
>				Version="1.0.0"
>				ModuleName="./Content/ListMyObjects.ms" />
>	</Components>
></ApplicationPackage>
> ```
> zip it and if our current bundle is located at `C:\my_bundle`, then before invoking the `3dsmaxbatch.exe`, we should write in Command Prompt
>
> ```bash
> set ADSK_APPLICATION_PLUGINS=c:\my_bundle
> ```
> This will make sure that before `3dsmaxbatch.exe` loads the scene and executes the work script, it will look into this folder and load the bundle located there.
>
> Next, we could write a simple working script (let us call it `run.ms`) that just invokes that function:
>
> ```sql
> ListMyObject()
> ```
>
> all what is left is just make sure that we are in the same folder as the running script and the scene (or specify the absolute/relative path) and run `3dsmaxbatch.exe run.ms -sceneFile myMaxFile.max`.
> After the task is complete, you should have a `list.txt` in your folder, listing all the objects from the scene.

This covered the simple use-case with no passed params. In case we need to pass some configuration params, the documentation on [3dsmaxbatch.exe](https://help.autodesk.com/view/3DSMAX/2019/ENU/?guid=GUID-48A78515-C24B-4E46-AC5F-884FBCF40D59) provides more details on this, but the essential are the following arguments:

```bash

 -mxsString arg    MAXScript String Parameter option, where arg=<key>:<value>
                    <value> will be accessible as a MAXScript string in
                    <script_file> through the maxOps.mxsCmdLineArgs dictionary
                    using <key> as the dictionary key.
                    Can be specified multiple times.

  -mxsValue arg     MAXScript Value Parameter option, where arg=<key>:<value>
                    <value> will be accessible as a MAXScript value in
                    <script_file> through the maxOps.mxsCmdLineArgs dictionary
```

As the documentation mentions, the arguments will be available to the work script through `maxOps.mxsCmdLineArgs` dictionary:

> Example: Consider the following Command Prompt invocation:
>
> ```bash
> >3dsmaxbatch demo_mxscmdline.ms -mxsString string1:"Hello"  -mxsValue value1:"[3,12,22]" -mxsValue value2:"Point3 3 8 2.3" -listenerLog "test.log"
> ```
>
> and the work script:
>
> ```sql
> opts = maxOps.mxsCmdLineArgs
>for k in opts.keys do (
>	format "% == % class: %\n" k opts[k] (classOf opts[k])
>)
>```
>
> the `test.log` file (we specified this file as the last argument) will contain:
>
> ```sql
> #string1 == Hello class: String
> #value2 == [3,8,2.3] class: Point3
> #value1 == [3,12,22] class: Point3
>
>```

All this is an important step in understanding the Design Automation workflow because when creating an activity, you have to specify the `commandLine` param, which will look like:

![](./img/activity.png)

and by now, this line should look familiar to you and we will get back to it later when creating an activity.

## 2.Upload the appbundle to the cloud
Once we have everything set and tested, we can prepare moving this workload to the cloud and make use of Design Automation API.

If locally, we can set `ADSK_APPLICATION_PLUGINS` environment variable, for the local 3ds Max to know where to find our appbundle, in context of Design Automation API, we will have to upload it somewhere in the cloud.
This is done in 2 steps:

1. Create an App through call to `https://developer.api.autodesk.com/da/us-east/v3/appbundles` by specifying

	```json
	{
	    "engine" : "Autodesk.3dsMax+2018",
	    "id": "myDemoApp"
	}
	```

	the reply from this code will contain a bunch of data, including the security parts:

	```json

	{
	    "uploadParameters": {
	        "endpointURL": "https://dasprod-store.s3.amazonaws.com",
	        "formData": {
	            "key": "apps/Denis/myDemoApp/1",
	            "content-type": "application/octet-stream",
	            "policy": "ey...X0=",
	            "success_action_status": "200",
	            "success_action_redirect": "",
	            "x-amz-signature": "01d...292",
	            "x-amz-credential": "AS...I/20181212/us-east-1/s3/aws4_request/",
	            "x-amz-algorithm": "AWS4-HMAC-SHA256",
	            "x-amz-date": "20181212T232929Z",
	            "x-amz-server-side-encryption": "AES256",
	            "x-amz-security-token": "FQ...4AU="
	        }
	    },
	    "engine": "Autodesk.3dsMax+2018",
	    "version": 1,
	    "id": "Denis.myDemoApp"
	}
	```

2. Upload the appbundle to `https://dasprod-store.s3.amazonaws.com` by passing as form-data the key-values received in the pervious request and specified as `formData` object. You will have to add the bundle file as value to the `file` key of this form.

gha_language: HTML

gha_license_id: MIT


text:
Linux  Building
===============
Built on Ubuntu 14.04 (Trusty)
### DAEMON
Obtain root access:
```
su
```
Update dependancy repository:
```
apt-get update
```
Install dependancies:
```
apt-get install git nano libminiupnpc-dev libqrencode-dev build-essential libssl-dev libboost-all-dev libdb++-dev
```
Download HOST source from github:
```
git clone https://github.com/Ace-Of-Fades/HOST.git
```
Move to the HOST src directory:
```
cd HOST/src
```
Edit file permissions for "leveldb" folder:
```
chmod -R 775 leveldb
```
Build the daemon:
```
make -f makefile.unix
```

In the src directory, search for "HOSTd". **You now have your daemon wallet!** If you would like to add the enviroment variable for quick and easy control of the wallet, continue to the step below. It's however, completely optional.

Open your ./profile file:
```
nano ~/.profile
```
(Add the following line to the bottom of the document, then save it.)
```
export PATH="$PATH:<Your HOSTd Location Directory>"
```
Now logout:
```
logout
```
When you log back in, you will be able to start the daemon by simply typing:
```
HOSTd
```
### QT
Obtain root access:
```
su
```
Update dependancy repository:
```
apt-get update
```
Install dependancies:
```
apt-get install git nano qt4-qmake libqt4-dev libminiupnpc-dev libqrencode-dev build-essential libssl-dev libboost-all-dev libdb++-dev
```
Download HOST source from github:
```
git clone https://github.com/Ace-Of-Fades/HOST.git
```
Move to the HOST directory:
```
cd HOST
```
Edit file permissions for "leveldb" folder:
```
chmod -R 775 src/leveldb
```
Build the daemon:
```
qmake && make
```

In the HOST directory, search for "HOST-qt". **You now have your QT wallet!**

repository: Ace-Of-Fades/HOST

path: /docs/Linux Wallets.md

filename: Linux Wallets.md

repo_name: Ace-Of-Fades/HOST


text:
<meta itemprop="name" content="tfp.experimental.substrates.numpy.math.log_combinations" />
<meta itemprop="path" content="Stable" />

# tfp.experimental.substrates.numpy.math.log_combinations

    View source on GitHub

Multinomial coefficient.

### Aliases:

* `tfp.experimental.substrates.numpy.math.generic.log_combinations`

``` python
tfp.experimental.substrates.numpy.math.log_combinations(
    n,
    counts,
    name='log_combinations'
)
```

Given `n` and `counts`, where `counts` has last dimension `k`, we compute
the multinomial coefficient as:

```n! / sum_i n_i!```

where `i` runs over all `k` classes.

#### Args:

* `n`: Floating-point `Tensor` broadcastable with `counts`. This represents `n`
  outcomes.
* `counts`: Floating-point `Tensor` broadcastable with `n`. This represents
  counts in `k` classes, where `k` is the last dimension of the tensor.
* `name`: A name for this operation (optional).

#### Returns:

* `log_combinations`: `Tensor` representing the multinomial coefficient between
  `n` and `counts`.

repository: davmre/probability

repo_name: davmre/probability


text:
# **Workout Tracker**

For this project, our application serves as a workout tracker where a user can add exercises to recent workout plans, create a new workout plan, and view the combined duration/weigths used from the past seven days. I was tasked to created a mongo database with a mongoose schema and handle all routes with Express.

![image](https://user-images.githubusercontent.com/52800632/108585822-7203a300-72ff-11eb-8a97-1af88101d535.png)
![image](https://user-images.githubusercontent.com/52800632/108585833-8182ec00-72ff-11eb-9f7a-c4bbe6a3cda4.png)

# **Installation**

Install required dependencies
```terminal
npm install mongoose
npm install express
npm install heroku
```

# **Built With**

 MongoDb - general purpose database built for modern application developers.

 Mongoose - MongoDB object modeling tool

 Javascript - scripting language that allows implementation of complex web features

 jQuery - Javascript library that simplifies javascript programming.

 HTML - The standard markup language for web pages

 CSS - used to describe the presentation of markup langauges such as HTML

# **Code Snippet**
Here I utulized the mongo built in aggregation method to take all of the duration data in the exercise array to add all of the numbers together and put out the data to a new field called totalDuration.
```js
 // Aggregate used to tally up the sum of exercise duration to populate totalDuration field
router.get("/api/workouts", (req, res) => {
  db.Workout.aggregate([
    {
      $addFields: {
        totalDuration: { $sum: "$exercises.duration" },
      },
    },
  ])
    .then((dbWorkout) => {
      res.json(dbWorkout);
    })
    .catch((err) => {
      res.json(err);
    });
});

```
```js
// Add exercise to workout
router.put("/api/workouts/:id", ({ body, params }, res) => {
  db.Workout.findByIdAndUpdate(
    params.id,
    // $push appends to the exercises array
    { $push: { exercises: body } },
    { new: true }
  )
    .then((data) => res.json(data))
    .catch((err) => {
      res.json(err);
    });
});

```
# **Deployed Link**

https://workouttracker-rc.herokuapp.com/
# **Authors**

Ron-Arjay Caluag

[Linkedin](https://www.linkedin.com/in/ron-arjay-caluag-00b29b182/)

[Github](https://github.com/ArjayCaluag)

The MIT License (MIT)

Copyright (c) 2011-2020 Twitter, Inc.

Copyright (c) 2011-2020 The Bootstrap Authors

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

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

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

repository: ArjayCaluag/Workout-Tracker

repo_name: ArjayCaluag/Workout-Tracker


text:
---
layout: simple-page
title: Cyberia Camp 2021
header: Cyberia Camp 2021
permalink: /events/cyberia/
breadcrumb: Cyberia Camp
redirect_from:
  - /cyberia/
---

![cyberia2021Poster]({{site.baseurl}}/images/cyberia.jpeg)

Cyberia 2021 is an annual Adobe Photoshop boot camp organized by NUSSU commIT, which aims to impart graphic design knowledge and skills to the participants to strengthen their skill set.
You will learn Adobe Photoshop with **training conducted by a certified professional Adobe Photoshop trainer** and **a series of challenging and exciting games**.
At the end of the camp, you will have the opportunity to put all the skills you learn to test by producing an artwork in our **competition** and stand to **win attractive prizes**!

**As a participant, you will receive:**

- Comprehensive Adobe Photoshop training + Certificate **(worth \$450)**
- Camp T-shirt
- Goodie bag

**Details of Cyberia 2021:**

<!-- need to change -->

- **Date:** 17th - 19th December 2020
- **Camp fee:** $30 **(worth $450)**
- **Venue:**
  - Online via Zoom
  - Offline in PC Clusters in E2

**Note**: The allocation of spaces are based on first-come-first-served basis based on the payment of camp fee. Your RSVP will only be confirmed upon completion of payment of camp fee. **No refund can be made upon payment.**

Do look up for emails once you completed the RSVP and the payment!

<!-- %%need to change%% -->

Sign up now at [http://bit.ly/Cyberia_2021](http://bit.ly/Cyberia_2021) to upskill yourself! See you in the camp!

## About Acadia Training

[Acadia Training Pte Ltd](https://www.acadia.sg) was established in July 2012. Our main focus is in corporate software training, especially in graphic and web design.

Since day one, we have been an official Training Partner of Adobe System Inc. All our classes are conducted by Adobe Certified Instructors (ACI), trainers who are certified subject matter experts and appointed by Adobe to conduct authorised training for Adobe software. Our trainers are known for their patience, friendly disposition as well as their willingness to provide help to their participants after the course.

Although we are a newly-formed company, our team is made up of veterans who have been in the training and design industry with at least 30 years combined experience.

At Acadia Training, our objective is to deliver quality and up-to-date IT courses that are relevant to current industry needs and to provide an enriching learning experience for all our customers.

## About the trainer: Han Guangwen

Han is an Adobe Certified Instructor, Certified Expert Specialist and Certified Expert Master in both Design and Web. Han graduated from the prestigious Bachelor of Design (Communication Design) program as a Distinction holder and worked as a successful graphic designer before switching to his true passion - training.

With detailed explanations and humorous style, Han’s trainees gain a strong understanding of each design tool and technique in a fun and easy-going setting. Emphasizing on the practicality of each design approach, Han backs each lesson with industrial-relevant scenarios, examples and case studies. As a dedicated trainer, Han’s trainees benefit from having him as a supportive advisor in their projects after attending his courses.

## Contact Us

If you have any enquiries, please feel free to reach out to us at [cyberia@nussucommit.com](mailto:cyberia@nussucommit.com).

repository: nussucommit/nussucommit

gha_language: CSS

repo_name: nussucommit/nussucommit


text:
# neushell
A simple, small unix shell.

# shell bultins
cd, pwd, mkdir, rmdir, exit

# functionalities
* shell bultin commands
* customisable prompt using PROMPT evnironment variable
* search for executables in PATH
* get/set environment variables
* standard I/O redirection to files
* unix pipes

# building
> gcc -neushell.c -o neushell

# TODO
* smarter error handling
* ironing out a few bugs
* more builtins
* read from config file


text:
---
title: Downloading InfluxDB Enterprise

aliases:
    - /enterprise/v1.3/introduction/download/

menu:
  enterprise_influxdb_1_3:
    weight: 0
    parent: Introduction
---

Please visit [InfluxPortal](https://portal.influxdata.com/) to get a license key and download URLs.
Also see the [Installation](/enterprise_influxdb/v1.3/introduction/meta_node_installation/) documentation to access the downloads.
You must have a valid license to run a cluster.
InfluxPortal offers 14-day demo licenses on sign-up.

gha_language: Less


text:
---
title : SkyPrenatal
permalink: projects/SkyPrenatal
header:
  image: /assets/projects/prague.PNG
  teaser: /assets/projects/prague.PNG

---
A compact, low-cost and self-sustaining telemedicine device carried by unmanned aerial vehicles(UAV) to provide prenatal care in resource-scarce communities

We participated a [competition](http://www.iupesm2018.org/) at a conference in Prague, Czech

Motivation
===

- 99% of maternal deaths happen in developing countries
- 830 women die from preventable causes related to pregnancy and childbirth every day
- The key obstacle is pregnant women's lack of access to quality skilled care before, during and after childbirth.
- Telemedicine devices can be a solution to prenatal care in resource-scarce communities

Goal
===
- Critical measurements of prenatal health care
- Screening for high-risk conditions
- Light-weight
- Self-sustaining
- Low-cost
- Easy to operate

To screen...
===
![](/assets/projects/prague1.png)

System
===
![](/assets/projects/prague0.png)
![](/assets/projects/prague2.png)

Components
===
![](/assets/projects/prague3.png)

User side interface
===
![](/assets/projects/prague5.png)

Physician side interface
===
![](/assets/projects/prague6.png)

Whole Device
===
![](/assets/projects/prague4.png)

User Manual
===

Reference
===
- Alkema, L., Chou, D., Hogan, D., Zhang, S., Moller, A., Gemmill, A., . . . Say, L. (2016). Global, Regional, and National Levels and Trends in Maternal Mortality Between 1990 and 2015, With Scenario-based Projections to 2030. Obstetric Anesthesia Digest,36(4), 191. doi:10.1097/01.aoa.0000504718.91214.7d
- Conde-Agudelo, A., Belizán, J. M., & Lammers, C. (2005). Maternal-perinatal morbidity and mortality associated with adolescent pregnancy in Latin America: Cross-sectional study. American Journal of Obstetrics and Gynecology,192(2), 342-349. doi:10.1016/j.ajog.2004.10.593
- Health - United Nations Sustainable Development. (n.d.). Retrieved from https://www.un.org/sustainabledevelopment/health/
- L. (2018, March 01). Live-Charts/Live-Charts. Retrieved from https://github.com/Live-Charts/Live-Charts
- Maternal and perinatal health. (2013, October 22). Retrieved from http://www.who.int/maternal_child_adolescent/topics/maternal/maternal_perinatal/en/
- Portable Digital Blood Pressure Monitor. (n.d.). Retrieved from https://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/s2005/ww56_ws62/Final Project Web/index.html
- Say, L., Chou, D., Gemmill, A., Tunçalp, Ö, Moller, A., Daniels, J., . . . Alkema, L. (2014). Global causes of maternal death: A WHO systematic analysis. The Lancet Global Health,2(6). doi:10.1016/s2214-109x(14)70227-x
- WHO recommendations on antenatal care for a positive pregnancy experience. (2016). Geneva: World Health Organization.

Demo video
===

Our team
===
![](/assets/projects/prague.jpg)

Award
===
![](/assets/projects/silver-award.jpg)

gha_language: JavaScript


text:
# QML flex layout

Qt quick layout system is real ugly. It would be much more convenient to use flexbox for positioning elements. This repository contains a set of qt quick bindings to the [Yoga](https://github.com/facebook/yoga) layout engine from React Native for rendering flexbox.

![Screenshot](docs/screenshot.png)

```
import QtQuick 2.5
import QtQuick.Window 2.0

Window {
    visible: true
    height: 400
    width: 675
    Rectangle {
        anchors.fill: parent
        color: "cyan"
        Flex {
            height: parent.height
            width: parent.width

            flexDirection: "row"
            flexWrap: "wrap"
            justifyContent: "spaceAround"
            alignItems: "center"
            alignSelf: "center"
            alignContent: "stretch"

            Rectangle { color: "green"; height: 150; width: 150 }
            Rectangle { color: "green"; height: 150; width: 150 }
            Rectangle { color: "green"; height: 150; width: 150 }
            Rectangle { color: "green"; height: 150; width: 150 }
            Rectangle { color: "green"; height: 150; width: 150 }
            Rectangle { color: "green"; height: 150; width: 150 }
            Rectangle { color: "green"; height: 150; width: 150 }
        }
    }
}

```

repository: tripolskypetr/qml-flexbox

repo_name: tripolskypetr/qml-flexbox


text:
ionic-rating
============

An angularjs directive that take care of visualising a star rating bar, build
for ionic.

![rating](https://cloud.githubusercontent.com/assets/1183541/3007107/3cee642c-de6c-11e3-8449-18b86ca130a7.png)

Also able to print half star (display only) :

![rating-half](https://cloud.githubusercontent.com/assets/7658059/12101509/67ee6d6c-b335-11e5-9ef6-0ceb92018fd2.png)

#### Why?

`angular-ui` has the same [rating](http://angular-ui.github.io/bootstrap/#/rating) directive,
but it is build on top of bootstrap. This repo just reuse most of the js code, but build for
the [ionic](http://ionicframework.com/) framework.

#### How to use?

Install with bower:

```
$ bower install ionic-rating
```

In your index.html

```HTML
<script src="lib/ionic-rating/ionic-rating.min.js"></script>
```

In you template:

```HTML
<rating ng-model="rating.rate" max="rating.max"></rating>
```

In you controller:

```JavaScript
// first inject it into your app
angular.module('youApp', ['ionic.rating'])

.controller('yourCtrl', function($scope) {

  // set the rate and max variables
  $scope.rating = {};
  $scope.rating.rate = 3;
  $scope.rating.max = 5;

});

```

For strict-di, you can use

```
.controller('RatingController', [ '$scope', '$attrs', 'ratingConfig', function($scope, $attrs, ratingConfig) ]
```

If you want to make it read only

> added readonly="readOnly" to rating directive, and $scope.readOnly = true; to the controller.

**Note:** You may also need to include the style file. But I suggest you just copy it to your
project.

#### Build

```
$ npm i
$ make all
```

#### License

MIT

repository: skounis/ionic-stage

repo_name: skounis/ionic-stage


text:
# Sud Web Talks

[![Build Status](https://travis-ci.org/sudweb/talks.svg?branch=master)](https://travis-ci.org/sudweb/talks)
[![NSP Status](https://nodesecurity.io/orgs/sud-web/projects/eaf659ee-9632-41ba-8005-9050dc85a991/badge)](https://nodesecurity.io/orgs/sud-web/projects/eaf659ee-9632-41ba-8005-9050dc85a991)

At [Sud Web](http://sudweb.fr), we manage *call for paper* via a Google Form.
This is nice and handy but totally unreadable.

This tool is a **frontend visualizer** of Sud Web talk proposals.
For the sake of our sanity.

![screenshot](https://sudweb.fr/img/talks-screenshot.png)

This project was bootstrapped with [Create React App](https://github.com/facebookincubator/create-react-app).

Below you will find some information on how to perform common tasks.

You can find the most recent version of this guide [here](https://github.com/facebookincubator/create-react-app/blob/master/packages/react-scripts/template/README.md).

## Install

Dependencies will be handled via `npm`.

`npm install`

## Developement

In the project directory, you can run:

`npm start`

Runs the app in the development mode.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

The page will reload if you make edits.

You will also see any lint errors in the console.

`npm test`

Launches the test runner in the interactive watch mode.

`npm run build`

Builds the app for production to the `build` folder.

It correctly bundles React in production mode and optimizes the build for the best performance.

The build is minified and the filenames include the hashes.

Your app is ready to be deployed!

`npm run deploy`

## Docker

To create the image, execute the following command in the project directory:

`docker build  -t=sudweb-talks .`

To run the image:

`docker run -it --name sudweb-talks -v $(pwd)/src:/app/src -v $(pwd)/public:/app/public -p 3000:3000 sudweb-talks`

## Google Spreadsheet

This app uses Google Spreadsheet as database. Read [Google Spreadsheet API docs](https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.values/batchGet) for more Details.
The spreadsheet must follow below structure :

### 1st sheet called "Propositions"

| Timestamp | Prénom et nom | Email | Titre de ta présentation | Formats | Description de ta présentation | Si le public ne devait retenir qu'une chose, ce serait... | Tu veux ajouter quelque chose ? |
|---|---|---|---|---|---|---|---|
| ... | ... | ... | ... | ... | ... | ... | ... |

### 2nd sheet called "Notes"

Subject | Total | Member's Name | Another member name | ...
---|---|---|---|---
Subject 1's title | 1 | 0 | 1 | ...
Subject 2's title | 2 | 1 | 1 | ...

repository: sudweb/talks

repo_name: sudweb/talks


text:
---
title: On Arrival in Singapore
permalink: /health/on-arrival
third_nav_title: Travelling to Singapore
---

### Arrival In Singapore

Depending on the traveller’s travel history, he/she may receive a Stay-Home Notice (SHN) and/or an electronic monitoring device during immigration clearance. To ensure a smooth clearance process, travellers must present the following documents to the immigration officer:

- Passport/Travel document that is valid for at least six months;
- SG Arrival Card acknowledgement email;
- Proof of Entry Approval (e.g. Approval email from Singapore Government agency, Safe Travel Pass approval or Air Travel Pass approval);
- Long-term pass or in-principle approval letter (if applicable); and
- Valid Singapore visa (if applicable).

Travellers should follow the instructions given by the officers at the immigration checkpoints on the allocation of the dedicated SHN facilities. Advance information on these facilities are unavailable due to the dynamic nature of room allocation for dedicated SHN facilities.

repository: fayeruzs/govtech-stp

repo_name: fayeruzs/govtech-stp


text:
---
name: Bug report
about: Create a report to help us improve

---

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Steps to reproduce the behavior:
1. Run the command '...'
2. Run the command '...'
3. See error '....'

**Expected behavior**
A clear and concise description of what you expected to happen.

**NO Screenshots**
If applicable, copy and paste the command and the output. Do not use screen shots, unless they add value to the report.  Text that can be edited is preferred to graphics.

**Environment:**
 - OS: [e.g. MacOs 10.12.6, Ubuntu 16.04]
 - dbdeployer version
 - tarball full name (e.g. mysql-5.6.40-linux-glibc2.12-x86_64.tar.gz)
 - tarball origin (from where it was downloaded)

**Hardware: (if applicable)**
 - Free storage
 - Total RAM

**Additional context**
Add any other context about the problem here.

repository: datacharmer/dbdeployer

gha_language: Go

repo_name: datacharmer/dbdeployer


text:
---
num: "lect02"
desc: " Hello World! + unix, vim and git"
ready: true
pdfurl: https://drive.google.com/drive/folders/1qG48RYFvB7VVEU7yP3eCkG8KRVA9KtYw?usp=sharing
lecture_date: 2019-01-10
---

# Basic Unix Commands

In the displayed commands, don’t include brackets. E.g., `mkdir [name]` will look like `mkdir tmp`, if you want to create a directory called `tmp`.

`pwd`
used to print the working directory - displays the full path

`ls` lists the contents of a directory; if no directory is specified, it will list the contents of the current directory

`ls -l`
lists the contents of a directory, and provides additional information about the file/directory;
distinguishes between files and directories (if the line starts with the letter ‘d’, then it corresponds to a directory, if not, then it corresponds to a file)

`mv [src] [dest]`
move a file/directory called `src` to a file/directory called `src`

`rm [file]`
deletes/removes a file (use with caution because it deletes files irrecoverably)

`rm -r [dir]`
recursively deletes the contents of a directory ;
if you use only `rm` for a directory, the operating system will complain and display the error message: `cannot remove [dir]: Is a directory`

`mkdir [name]`
make a new directory called `name`

`mkdir -p [level1/level2/...]`
allows you to create a series of nested directories

`cd`
used to change directory you are currently located in

`~`
refers to the home directory

`..`
refers to the directory above the current one

`cd ..`
goes to the directory above the current one

`cd ~`
goes to the home directory

`./[name]`
used to execute a compiled program

# Vim Commands

The link below is a very useful guide to learn fundamental commands in Vim (most of these were shown in lecture on January 10th):

https://ucsb-cs16.github.io/topics/vim_basic_eight/

# Topics
* Programming in the unix environment
* The vim (editor) survival skills
* Writing, compiling and running a C++ program (hello world) program
* Breaking down the hello world program
* Code anywhere and everywhere with git

# Programming in the unix environment
* Unix is an operating system just like Windows and Mac OS
* All your data and programs are stored in files, within the unix filesystem
* File vs. directory
* Files are organized within the *unix filesystem*
* You can navigate the filesystem with some simple commands inside a terminal:
	- ls
	- mv
	- cp
	- pwd
	- mkdir
	- cd
* Relative path vs. absolute path (important for mv, cp, mkdir, cd)

# vim Editor

* We will use vim for the first few weeks this quarter.
* Important to be comfortable with a Unix-based command-line text editor.
* Be sure to understand how to do the [basic eight](https://ucsb-cs16.github.io/topics/vim_basic_eight/) functions.

# Writing, compiling and running a C++ program (hello world) program

```
// hello.cpp
#include <iostream>

using namespace std;

int main() {
	cout << "Hello CS 16!" << endl;
	return 0;
}
```

* Compile and execute the program

```
$ g++ -o hello hello.cpp
$ ./hello
Hello CS 16!
$
```

* `g++` is one of several C++ compilers
	* Compilers translate "source code" (i.e., the contents in the .cpp file) into a lower-level representation that is easier for computer system hardware to understand.
* `-o` is a "flag" that instructs the g++ compiler to produce an executable file called `hello`
* `hello.cpp` is the source file for g++ to use when producing the executable file.
* In order to actually run an executable file in Unix, `./[filename]` is used.

# Breaking down the Hello World Program

```
// hello.cpp
#include <iostream>

using namespace std;

int main() {
	cout << "Hello CS 16!" << endl;
	return 0;
}
```

```
#include <iostream>
```

* This line (also known as an include directive) tells our C++ program to include a library dealing with Input/Output (I/O) functionality.
	* We need the library `<iostream>` to print stuff to our terminal.

```
using namespace std;
```

* This line allows us to use parts of the iostream library without having to prepend `std::`.
	* For more context, `std` is short for "standard".
	* including libraries between angle brackets (< >) imply that this is part of the C++ Standard Library, which is part of the C++ language specification.

```
int main() { ... }
```

* The main function. Every C++ program needs to have one main function as its "starting point".

```
cout << "Hello CS 16!" << endl;
```

* `cout << [some_value]` tells the program to display some_value to the terminal.
* `<< endl;` tells the program to insert a <i>newline</i> at the end.
	* This places the next values to be written on the next line in the terminal.

```
return 0;
```

* Since main must be declared to return a value of "int" type, we are simply returning 0.
	* May get more into the relevance of this later.

# Comments

* Any commented text will be ignored by the compiler.
* Important to comment code for communication with others working with your code!
* `//` denotes a single-line comment.
* `/* */` denotes a multi-line comment.


text:
---
title: Next big project
excerpt: My next big project ...
category:
  - blog
header:
  overlay_image: /images/header-vscode.png
  overlay_filter: 0.75
  teaser: /images/teaser-vscode.png
tags:
  - vscode
  - puppet
  - extension
---

Not so much a blog post this time, more a note of things to come.  I've been thinking of a project I'd like to build.  I've done some work with containers and I stil love my Neo4j graph databases and of course Windows related things.  But I wanted something, a bit more challenging...

So I decided on writing [Visual Studio Code Language Client and Server](https://code.visualstudio.com/docs/extensions/example-language-server) for Puppet.

I'll keept the blog update with my progress...

### Why?

Writing Puppet manifests is ok, but it could really be so much easier with things like intellisense and parameter completion etc. and access to current Facter facts.  Also it would be nice if you could run Puppet commands from inside VS Code instead of running a seperate console.

* Puppet-Agent already installs Ruby and some gems so there's no overhead to install Ruby

* Ruby supports many types of pipes STDIN/STDOUT, Named Pipes and TCP based pipes so we can talk between Ruby and VS Code easy enough

* There's a lot of prior art I can use, particularly the PowerShell Language Server as I can code in C#

* I'd like to have this ready for the Puppet Contributor Summit in October 2017

* Puppet already exposes Abstract Syntax Tree (AST) and I can use the code in the Puppet REPL to help

### So what do I want to build

High level goals

* Get some basic [intellisense](https://code.visualstudio.com/docs/editor/editingevolved#_intellisense) for Puppet files (.pp)

  - Resource parameter/property names

  - Function names

  - Facter names (Legacy and Structured) and include their current values as [Parameter Hints](https://code.visualstudio.com/docs/editor/editingevolved#_parameter-hints)

* Syntax highlighting

* Run Puppet commands from the Command Palette (puppet module, puppet facts)

* The Client and Server will communicate over TCP, but for the moment only localhost and only for Windows platforms

Stretch goals

* Linting

* Use VS Code on Windows to communicate with a Language Server on a Linux based OS

* [Show Errors and Warnings](https://code.visualstudio.com/docs/editor/editingevolved#_errors-warnings)

* [Code Folding](https://code.visualstudio.com/docs/editor/editingevolved#_folding)

gha_license_id: NOASSERTION


text:
# Docker Ambassador with SSL capabilities

https://github.com/jnovack/docker-ambassador

Docker Ambassador is a tiny Alpine-based ambassador container for tunnelling and optionally securing your client-server connections that are unable to otherwise communicate or secure.

**Features**
* alpine-based image
* socat for relaying traffic
* Uses supervisor for monitoring the socat processes

**References**
* https://github.com/bandesz/docker-ambassador
* https://github.com/md5/ctlc-docker-ambassador
* https://github.com/zbyte64/stowaway-ssl-ambassador
* https://docs.docker.com/articles/ambassador_pattern_linking/

```
( client                            )                 ( server                            )
( mysql-client -> client-ambassador ) --> network --> ( server-ambassador -> mysql-server )
                 [ ----------------- secure tunnelling ----------------- ]
```

## Example

Run server service:
```
docker run --name mysql-server -e MYSQL_ROOT_PASSWORD=pass -d mysql
```

Run server ambassador:
```
docker run -d --link mysql-server:mysql-server --name server-ambassador \
        -p 3306:3306 jnovack/ambassador
```

Run client ambassador:
```
docker run -d --name client-ambassador --expose 3306 \
        -e MYSQL_PORT_3306_TCP=tcp://<IP_ADDRESS>:3306 jnovack/ambassador
```

Run client:
```
docker run -it --link mysql-ambassador:mysql-server \
        --name mysql-client mysql bash
```

## Environment Variables

All environment variables are optional.

* `SSL` - One of `server` or `client`. Instantiates the container as the client or server container in terms of SSL termination.
* `SERVER_PRIVATE_KEY` - The server's concatenated private key and public certificate. Used on the server.
* `SERVER_PUBLIC_KEY` - The server's public certificate.  Used on the client for server verification.
* `CLIENT_PRIVATE_KEY` - The client's concatenated private key and public certificate. Used on the client.
* `CLIENT_PUBLIC_KEY` - The client's public certificate.  Used on the server for client authentication.

If you provide a `SERVER_PUBLIC_KEY` to the client, you will only be able to connect to the servers with certificates in `server.crt`.

If you do not provide `SERVER_PUBLIC_KEY` to the client, then the server will not be verified, but still encrypted.

If you provide `CLIENT_PUBLIC_KEY` to the server, only clients with certificates matching in `client.crt` will be permitted to connect. If you do not provide `CLIENT_PUBLIC_KEY` any client may connect.

You can `cat` multiple `client.crt`s together to allow for multiple clients.

## Enable SSL

OpenSSL has been added to the image so you can secure, and optionally authenticate the connection.

The container will automatically generate certificates if you do not pass any in through the environment when you add the `SSL` environment variable.

By default with SSL enabled, the connection is encrypted but it is not authenticated, not a big deal for your average tunnel session, but for enhanced security, it will print out the certificate so you can copy it to the other end.

For server verification, copy the server's `server.crt` to the client and provide `SERVER_PUBLIC_KEY` to the client ambassador.

For client authentication, copy the client's `client.crt` to the client and provide `CLIENT_PUBLIC_KEY` to the server ambassador.

repository: jnovack/docker-ambassador

repo_name: jnovack/docker-ambassador


text:
# 9. Lists are optional

Date: 2021-09-08

## Context

When deriving or implicitly inferring a schema for a collection-value type `T` (e.g. `List[String]`), should the
resulting `Schema[T]` be optional, or not? That is, what should be the value of the `Schema[T].isOptional` field?

On one hand, the collection can be empty, just as an `Option[T]` can be empty, which would indicate that this value
is optional. On the other, when a json object contains a collection-valued field, there are four possible states:
an entirely missing field, a field with a `null` value, an empty array `[]`, or a non-empty array. In this scenario,
one could consider `List[String]` to allow only empty and non-empty array values, while `Option[List[String]]` would
allow all four.

## Decision

Schemas for collection-valued types are optional. This is because when deriving/inferring schemas, there is no context,
that is, we don't know whether we are deriving a schema for a query parameter, a header, or a json field. In many cases,
making collection schemas optional is the only sensible choice: e.g. `query[List[String]]("x")` is obviously optional,
as there are only two possible states: either there are no query parameters with name `x`, or there are multiple ones.
Similar for headers. Even for body values, this often makes the same sense: when parsing the body as a comma-separated
list of values, or when generating the schema for an xml body, where children elements can be repeated or not (there
are no `null` values).

This is different for json, though, as a field can be absent or `null`-valued. In the current representation, `Schema`s
make no distinction between a missing field, or an empty array. Json parsers might behave differently - though this
isn't something that can be generically supported; so either the json parsers, or the schemas will have to be adjusted
accordingly.

As a work-around, if needed, there are several options:

* use a dedicated type, for which a schema can be separately defined, just as the schema for `NonEmptyList` from the
  cats integration is required
* define a local implicit:

```scala
implicit def schemaForIterable[T: Schema, C[X] <: Iterable[X]]: Schema[C[T]] =
  implicitly[Schema[T]].asIterable[C].copy(isOptional = false)
```

when deriving the schema for a type that is later serialised to json, e.g. in a block in which `jsonBody` is called.

* [customise](https://tapir.softwaremill.com/en/latest/endpoint/schemas.html#customising-derived-schemas) the derived
  schemas

repository: softwaremill/tapir

gha_language: Scala

repo_name: softwaremill/tapir


text:
This file contains some common collision detection algorithms that are used in various applications such as video games, computer animation, and robotics.

Collision detection, simply put, is detecting if two (or more) objects are intersecting.

The following links provide helpful pseudocode for understanding how collision algorithms work.

* http://devmag.org.za/2009/04/13/basic-collision-detection-in-2d-part-1/
* http://devmag.org.za/2009/04/17/basic-collision-detection-in-2d-part-2/

repository: ju-arroyom/Haskellese

repo_name: ju-arroyom/Haskellese


text:
---
layout: doc
sublayout: guide
title: Pushing and Pulling Repositories
reviewed: 2017-04-27T16:29:15-04:00
---
### Pushing a repository to Quay.io

Note: pushing to a repository requires **Repository Write Access**.
Note: you should have a name for the image before you push it

In order to push a repository to Quay.io, run the following command:

```
$ sudo docker push quay.io/namespace/repository:tag
```

### Pulling a repository from Quay.io

Note: pulling from a repository requires **Repository Read Access** for private repositories.

To pull a repository from Quay.io, run the following command:

```
$ sudo docker pull quay.io/namespace/repository
```

repository: coreos/quay-docs

branch_name: refs/heads/gh-pages

repo_name: coreos/quay-docs


text:
# How to present slideshow on GitPitch

## On a branch
### Branch name
e.g. MyBranchName

### URL
Project, user:   https://gitpitch.com/tari-labs/tari-university/

Tree location:   MyBranchName?p=/

Presentation:    src/cryptography/scriptless-scripts#/

Final URL:

https://gitpitch.com/tari-labs/tari-university/MyBranchName?p=/src/cryptography/scriptless-scripts#/

## On the trunk
### Trunk name
e.g. master
### URL
Project, user:   https://gitpitch.com/tari-labs/tari-university/

Tree location:   master?p=/

Presentation:    src/cryptography/scriptless-scripts#/

Final URL:

https://gitpitch.com/tari-labs/tari-university/master?p=/src/cryptography/scriptless-scripts#/

repository: kamyau/tari-university

repo_name: kamyau/tari-university


text:
## Optimum polynomial
### Problem 101

If we are presented with the first $k$ terms of a sequence it is impossible to say with certainty the value of the next term, as there are infinitely many polynomial functions that can model the sequence.

As an example, let us consider the sequence of cube numbers. This is defined by the generating function,

$u_n = n^3$: 1, 8, 27, 64, 125, 216, ...

Suppose we were only given the first two terms of this sequence. Working on the principle that "simple is best" we should assume a linear relationship and predict the next term to be 15 (common difference 7). Even if we were presented with the first three terms, by the same principle of simplicity, a quadratic relationship should be assumed.

We shall define $OP(k, n)$ to be the $n$th term of the optimum polynomial generating function for the first $k$ terms of a sequence. It should be clear that $OP(k, n)$ will accurately generate the terms of the sequence for $n \leq k$, and potentially the *first incorrect term* (FIT) will be $OP(k, k+1)$; in which case we shall call it a *bad OP* (BOP).

As a basis, if we were only given the first term of sequence, it would be most sensible to assume constancy; that is, for $n \geq 2, OP(1, n) = u_1$.

Hence we obtain the following OPs for the cubic sequence:

$OP(1, n) = 1$ : $1, \color{red}{1}\color{black}{, 1, 1, ...}$

$OP(2, n) = 7n−6$ : $1, 8, \color{red}{15}\color{black}{, ...}$

$OP(3, n) = 6n^2−11n+6$ : $1, 8, 27, \color{red}{58}\color{black}{, ...}$

$OP(4, n) = n^3$ : $1, 8, 27, 64, 125, ...$

Clearly no BOPs exist for $k \geq 4$.

By considering the sum of FITs generated by the BOPs (indicated in $\color{red}{red}$ above), we obtain 1 + 15 + 58 = 74.

Consider the following tenth degree polynomial generating function:

$$u_n = 1 − n + n^2 − n^3 + n^4 − n^5 + n^6 − n^7 + n^8 − n^9 + n^{10}$$

Find the sum of FITs for the BOPs.

repository: stdstring/projecteuler

gha_language: F#

repo_name: stdstring/projecteuler


text:
BLE framework is a Unity library that you can use to easily manage the Bluetooth communication between your mobile device and a ReadBearLab BLE boards.
The supported boards are:
* BLE Shield
* BLE Mini
* Blend Micro
* Blend
* BLE Nano
* RBL nRF51822

The ReadBearLab BLE boards can be attached to a micro controller such as Arduino to allow simple wireless serial communication with your mobile device.

The sample Unity project inside the folder Unity contains two sample scenes to get started using the framework.
1) RobotServer: build this scene for testing BleMini with Arduino Mega + Adafruit Motor Shield with 4 DC Motors. The code for Arduino is inside the folder Arduino/RobotClient. Read this article for details on how to wire the Adafruit Motor Shield with 4 DC Motors: https://learn.adafruit.com/adafruit-motor-shield-v2-for-arduino/overview
2) MeteoStation: build this scene for a sample app for temperature and humidity sensor reading. The hardware setup is BleMini with Arduino Mega + Sparkfun RTH03 sensor.  Read this article for details on how to wire the humidity and temperature sensor: https://learn.sparkfun.com/tutorials/rht03-dht22-humidity-and-temperature-sensor-hookup-guide/all
You can find the code for Arduino inside the folder Arduino/MeteoServer.
In both hardware configurations (RobotClient and MeteoServer) the BleMini Rx and Tx pins must be wired respectively to the Tx1 18 and Rx1 19 digital pins of the Arduino Mega 2560.

Before building the Unity project for Android targets, you need to generate the android plugin using the AndroidPlugin project. You can open this project using Android Studio, then click on Run 'copyPlugin' to generate and copy the plugin in the BleFramework/Assets/Plugin/Android folder.
Now you are ready to build the Unity project for Android targets.
VERY IMPORTANT FOR ANDROID: When running the android example app the first time you have to grant permission for Location in the Android apps settings menu. No popup is prompt asking for permission and you have to grant the Location permission manually. If you don't give Location permission the BLE scan will return empty result.

As mentioned before Android plugin is generated by the AndroidPlugin Android Studio's project. You can find the code inside the 'bleframework/src' subfolder.

As regard iOS you can find the plugin source code inside the folder Unity/Assets/Plugins/iOS/BLE.

If you want to modify the plugins you can just modify the source code in these folders.

repository: DoctorrLab/ble-framework

repo_name: DoctorrLab/ble-framework


text:
# pyIntertidalDEM
pyIntertidalDEM is a set of libraries and procedures written in python to
extract shorelines from spectral images using a sophisticated shoreline extraction
algorithm.

These modules are developed in Python v3 environment and it is recommended to run
the program in Python v3 rather than Python v2.

## Setup and Processing
Step 1: Run depcheck.py for checking for library and dependency error checks

Step 2: See example.py for example analysis setup

## Publications
The result of this work is currenly being communicated. Once published, the
link will be posted here.

## Documentation
Currently the program is documented at source level and strongly believed that
the use of the program falls on the left side of the xkcd documentation spectram!

![XKCD MANUAL](https://imgs.xkcd.com/comics/manuals.png)

repository: edtrochim/pyIntertidalDEM

repo_name: edtrochim/pyIntertidalDEM


text:
![License Badge](https://img.shields.io/badge/license-MIT-green)

# README Generator

## TABLE OF CONTENTS

* [Description](#description)
* [Installaion](#installation)
* [Usage](#usage)
* [Contribute](#contribute)
* [Testing](#testing)
* [Credits](#credits)
* [License](#license)

## DESCRIPTION

When creating an open source project on GitHub, it’s important to have a high-quality README for the app. This is an application that uses NODE to generate a README Markdown file based on user input, by asking a series of questions in the comman line.

## INSTALLATION

First, download the files from this repository, then open the terminal. Inside the folder, use 'npm init' to initialize npm package, then 'npm i' to install dependencies. Your project is ready for use!

### USAGE

This application can be invoked by entering the following command into the terminal

```bash
node index.js
```

You will then be given a series of questions to answer. Your responses to these answers will be used to generate your new README file.

[Here is a link to the video tutorial](https://drive.google.com/file/d/1nmGZE_kYOEElJxQRK2SvyqmkTjvf7Jbr/view?usp=sharing)

![Command Line in Action](images/in-action.png)

## CONTRIBUTE

Contributors are not necessary on this project. However, if youy would like to contribute feedback, please do!

### TESTING

This project was tested by its creator.

### CREDITS

This project was created by [Christina Moss](https://github.com/cmoss703).

Email<EMAIL_ADDRESS>
Github Repo: https://github.com/cmoss703/README-generator

Link to Deployed Site: [README Generator](https://drive.google.com/file/d/1nmGZE_kYOEElJxQRK2SvyqmkTjvf7Jbr/view?usp=sharing)

#### License

    This Project is licensed for use by MIT.


text:
_[home](../README.md)_

# Queue

The `cloud-starter` Big App pattern is based on a full event-based cloud application architecture, based on [Redis Stream](https://redis.io/topics/streams-intro), which has all services talking to a bus/queue, and avoid any service-to-service direct communication.

![](images/arch-queue.png)

## Overview

Here are the key points of such architecture:

- Queues are based on [Redis Stream](https://redis.io/topics/streams-intro)
- **Queue event messages** are **fully typed** via TypeScript. (see [event-types.ts](../shared/src/event-types.ts))
- There are two type of queues:
  - **Application Queues** are data and notification events such as new content available in the store buckets or other application notifications.
  - **Job Queues** are specialized queues that represents work to be done by a service (.e.g., [vid-scaler](../services/vid-scaler/) which scale down a video after it's main MP4 version is vailable). Typically, there isone Job Queue Event type per Job Service.
- **Job Service** are services that listen to a redis job queue _stream_ with a specific _redis group_, allowing multiple instances of a service to get messages that was not already delivered to another consumer.
- **Bridges** are processes that bridge two queues, typically an Application Queue with a Job Queue. By best practice, the bridges are usually within their corresponding Job Service container.
  - For examples:
    - A [vid-init](../services/vid-init/) job service will create nodejs worker thread to bridge `MediaNew` application event to a `VidInitJob` for any media of type video. See [vid-init/src/wkr-bridge-media-new.ts](../services/vid-init/src/wkr-bridge-media-new.ts)
    - A [vid-scaler](../services/vid-scaler/)  job service will create a new worker thread to bridge `MediaMainMP4` (when the main MP4 is available) to the `VidScalerJob` queue. See [vid-scaler/src/wkr-bridge-media-mp4.ts](../services/vid-scaler/src/wkr-bridge-media-mp4.ts)
  - Best practice:
    - Bridges are Nodejs Worker Thread, one file per bridge, starting with `wkr-...ts`, and they are started on the appropriate service `start.ts`.

## Redis Stream, Redstream, and Queue APIs intro

- [Redis Stream](https://redis.io/topics/streams-intro) is a persistent list of data maintained by Redis.
- It allows us to have a full message queue system in a very simple and efficient manner.
- The Redis Stream APIs start with `X` such as [XADD](https://redis.io/commands/xadd), [XREADGROUP](https://redis.io/commands/xreadgroup).
- The [redstream](https://www.npmjs.com/package/redstream) will be used to query the redis stream server. It uses [ioredis](https://www.npmjs.com/package/ioredis) as backend (which needs to be installed as it is defined as peer dependency)
  - A Stream entry has a `.id` which is typically created by redis on `.xadd(data)` and a `.data` which is TypesScript typed when using _redstream_
  - Each Stream has a unique key, e.g., `VidScalerJob` or `MediaNew`, and the Redis API allows adding entries (name/value pair).
  - With the _redstream_ API, you first create a `redstream` object, with a given key
    - `const mediaNewStream = redstream(ioredisClient, 'MediaNew')` (in application code, a factory module should be used to allow caching, typing, normalization, see [queue.ts](../services/_common/src/queue.ts))
  - Adding new entries is done with `queue.xadd(data)`
    - `mediaNewStream.xadd({type: 'MediaNew', wksId: 11, mediaId: 123, mediaMimeType: 'video/mov'})` (all should typed, see [../shared/src/event-types.ts], and the `.type` property is required and must match the event type name)
  - Reading (blocking) is done with `await stream.xreadgroup(group, consumer)` (where consumer_ID is usually `KHOST`)
    - `group` is a way to group all of the callers so that they only get messages that have not been delivered to another consumer of the same group.
    - `consumer` allows to identify which client/instance read the message. Typically, this will be the KHOST. (Redis Stream allows to `xinfo` a stream and get that information)
    - `const entry = await mediaNewStream.xreadgroup('VidInitJobBridge', KHOST))`. with `entry = {id:string, data: MediaNew}`. This example is used to bridge the `MediaNew` queue to another queue.
    - After an entry is read with `xreadgroup` it has to be `xack` to remove it to the pending list of this group once it is deemed processed. This is like an acknowledgment that the entry was processed. This is done with `stream.xack(group, entry.id)`
- `getAppQueue` and `getJobQueue` from [queue.ts](../services/_common/src/queue.ts) are thin application wrapper used to add queue semantic.
  - `const queue = getAppQueue('MediaNew')` is used to get a use for a specific event type name
  - `queue.next(groupName)` is used to get the next entry.
  - `jobQueue.nextJob()` is used to get the next entry of a job queue to perform the job (the group name is inferred from the event name)
  - `queue.add({...})` is used to add some data.
  - All of those are type accordingly to the [../shared/src/event-types.ts]

## Notes

- Right now, the cloud-bigapp code create a new `ioredis` client for each `getAppQueue` call, which could be optimized.
- However, sharing of `ioredis` client will prevent a call to do a redis call (`.xadd`) if before it had a blocking call. Consequently, all queue are safer, for now, to have their own client until we have an API scheme that allows requesting a "add only" queue interface (i.e., without the `.next..` methods)

repository: BriteSnow/cloud-starter

repo_name: BriteSnow/cloud-starter


text:
---
layout: post
title:  "Modernizr 3.11.0"
author: Rejas
---

We might be living in interesting times, two releases in one month :-) Getting a small release out the door
before work on v4 starts. Stay tuned for that...

**New Feature Detect(s)**

[@dabretin](https://github.com/dabretin) continued his addition of es6 and beyond:
- ES6 - class [`#2532`](https://github.com/Modernizr/Modernizr/pull/2532)
- ES8 - object [`#2533`](https://github.com/Modernizr/Modernizr/pull/2533)
- TextEncoder and TextDecoder [`#2531`](https://github.com/Modernizr/Modernizr/pull/2531)

[@MarkelFe](https://github.com/MarkelFe) added:
- av1 and h265 codec detection [`#2534`](https://github.com/Modernizr/Modernizr/pull/2534)

**Fixes**
- [@Sembiance](https://github.com/Sembiance) fixed an issue with AVG Secure browser throwing exceptions when using toDataURL when Anti-Fingerprinting is turned on [`#2538`](https://github.com/Modernizr/Modernizr/pull/2538)
- [@MarkelFe](https://github.com/MarkelFe) added some missing caniuse mappings [`#2535`](https://github.com/Modernizr/Modernizr/pull/2535)

**Miscellaneous**

- Update computedStyle usage [`#2528`](https://github.com/Modernizr/Modernizr/pull/2528)
- Cleanup property tags [`#2542`](https://github.com/Modernizr/Modernizr/pull/2542)
- Change property name for es6 class test [`1baf805`](https://github.com/Modernizr/Modernizr/commit/1baf805e9eb54710f6ad122a4f6557f6e369c530)

repository: Modernizr/modernizr-neue

extension: markdown

repo_name: Modernizr/modernizr-neue


text:
# RecoveryBox
> Full-Stack RecoveryBox mobile app containing both client (front-end) and server (back-end).

[![GitHub license](https://img.shields.io/github/license/davzhardy/RecoveryBox)](https://github.com/davzhardy/RecoveryBox/blob/master/LICENSE)
[![GitHub issues](https://img.shields.io/github/issues/davzhardy/RecoveryBox)](https://GitHub.com/davzhardy/RecoveryBox/issues)
[![shields.io](https://img.shields.io/badge/made%20with-💕-blue?style=flat-square)](https://shields.io)

RecoveryBox is a mobile app aimed to help people in their journeys through twelve-step recovery programmes such as Alcoholics Anonymous. The app is a tool for people to record their meeting attendance, moods and the difficulties they encounter in their day-to-day lives.

It documents the efforts made by programme participants and encourages continuing, sustainable interaction and self-reflection to stay on top of their recovery.

## Presentation

RecoveryBox was originally developed as a Solo Project for the Codeworks coding bootcamp. You can find a short video describing the project in further detail on [youtube](https://www.youtube.com/watch?v=FD78fHjs5BA).

## Installation

The app is built using react native, which means you'll need a way to run the app on a phone or emulator. To do this, you'll need to install [expo](https://expo.io/), follow the steps below to get it up and running:

1. Download [expo](https://expo.io/learn)
2. Install expo from your terminal

   ```
   npm install expo-cli --global
   ```

## Getting Started

1. Clone this repo!

   ```
   git clone https://github.com/davzhardy/RecoveryBox.git
   ```

2. Install dependencies and start the server.

   ```
   cd server      # Change into the server folder
   npm install    # Install dependencies
   nodemon        # Fire up the server
   ```

3. Install dependencies and start the client.

   ```
   cd ../client	  # Change into the client folder
   npm install    # Install dependencies
   expo start     # Start the Expo development environment that will build the JS bundle for the app
   ```

3. The Metro Bundler will now load in a new browser window and you can choose the platform where you want launch app.

4. Scan the barcode with the Expo app on your phone or follow the terminal instructions to load up the emulator on your machine.

## Tech Stack

*FrontEnd*
* [React Native](https://facebook.github.io/react-native/)
* [Redux](https://redux.js.org/)

*BackEnd*
* [Node.js](https://nodejs.org/)
* [Express](https://expressjs.com)
* [Sequelize ORM](https://sequelize.org)
* [PostgreSQL](https://www.postgresql.org)

## Author

David Hardy - [Github](https://github.com/davzhardy) - [Linkedin](www.linkedin.com/in/david-hardy50)

Also check-out the development branch where [Daniel Alejandro Hernández Llerena](https://github.com/danielhdezller) did a great job extending the project to add Authentication and Testing.

## License

MIT © [David Hardy](https://github.com/davzhardy)

repository: davzhardy/RecoveryBox

repo_name: davzhardy/RecoveryBox


text:
# `ngAppSeed` — Joel's seed for AngularJS 1 apps

This project contains the generic application skeleton for a typical [AngularJS][angularjs] web app.

The seed contains a sample AngularJS application and is preconfigured to install the Angular
framework and a bunch of development and testing tools for instant web development gratification.

## Getting Started

Clone the `ngAppSeed` repository
Run bower install into the `./app/core` folder
Run npm install into the `./app/core` folder
Run npm install into the `./` folder

You can run the app running `npm start` or `http-server -a localhost -p 8000 -c-1 ./app`

### Prerequisites

You need:
- Git to clone the repository. You can get git from [here][git].
- Node.js and its package manager (npm). You can get them from [here][node].
- Bower to manage your packages. You can get `bower` from [client-side code package manager][bower].

### Clone `ngAppSeed`

Cd into the folder where you want your app to be.
Run git clone there:

```
git clone https://github.com/joelbarba/ngAppSeed <your-project-name>
```

If you just want to start a new project without the commit history then you can also do:

```
git clone --depth=1 git clone https://github.com/joelbarba/ngAppSeed <your-project-name>
```

The `depth=1` tells git to only pull down the last commit, and ignore the historical data.

### Core

In order to pack all our bower components and other main modules that will be userd throughout the app, there is a `core` module set at a different level. All bower components must be added there. We can add our main components and scss files here as well.
Once compiled, we add them to the index.html file of the app through 4 files:
- core/dist/styles/vendor.css
- core/dist/styles/core.css
- core/dist/scripts/vendor.js
- core/dist/scripts/core.js

### Run the Application

We have preconfigured the project with a simple development web server. The simplest way to start
this server is:

```
npm start
```

Now browse to the app at [`localhost:8000/index.html`][local-app-url].

## Directory Layout

```
app/                    --> all of the source files for the application
  app.css               --> default stylesheet
  core/                 --> core modules
    dist/                 --> compiled core
    src/                  --> source code for the core
  components/           --> all app specific modules
    version/              --> version related components
  view1/                --> the view1 view template and logic
    view1.html            --> the partial template
    view1.js              --> the controller logic
  view2/                --> the view2 view template and logic
    view2.html            --> the partial template
    view2.js              --> the controller logic
  app.js                --> main application module
  index.html            --> app layout file (the main html template file of the app)
```


text:
<p align="center">

## Sakshya - The Document Authentication E-Platform

(_solution designed During the VIVIDH initiative by B_chain Dynamics)
The name Sakshya is not permanent, and will be changed soon.

## Overview

Sakshya is a document authentication platform with the integration of cloud technology, in order to provide strong security, attack mitigation, and public auditing for transparency.

Sakshya's two main objectives are:

- To achieve **public acceptance** regardless of the user's technical blockchain knowledge
- To empower any kind of public with **blockchain-driven technology** to promote Authencity

## Architecture

Sakshya leverages the advantages of [Ethereum Network](https://ethereum.org/en/), which is a blockchain decentralized application platform that provides hybrid _proof-of-stake_ and _proof-of-work_.

The system creates a bridge between decentralized **Ethereum Blockchain Network** with centralized database.

## Key benefits

- On-chain transactions
- Wallet Based Application
- Secure cryptographic signatures
- Flexibility for everyone


text:
# G Suite Utilities

Scripts handy for admining G Suite domains and organizations

## Intsall

0. If Python isn't installed on your computer, download and install
   [Miniconda](https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh)
1. download this repository to your computer (either via Git or download and extract the Zip file)
2. setup this program
   ```sh
   cd gsuite-utils

   pip install -e .
   ```

## Usage

### Bulk User Add
A certain organization with G Suite "mydomain.org" has an Excel spreadsheet from HR Dept. with certain columns when they add new users in bulk.
G Suite wants a specially formatted CSV file.

1. convert the HR spreadsheet to G Suite CSV
   ```sh
   python bulk_useradd.py newusers.py newusers.csv mydomain.org hash password_length
   ```
2. upload `newusers.csv` to G Suite via [Bulk User Add](https://support.google.com/a/answer/40057)

repository: scivision/gsuite-utils

repo_name: scivision/gsuite-utils


text:
---
layout: default
---

# 1997-05-29 - pathology

## Header Data

From: Secret Squirrel<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: efa80d3e74e6652db0ddc98d58ec4f0b4e29aa182e5ebf84e94e3353011d21e2

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-05-29 13:15:34 UTC

Raw Date: Thu, 29 May 1997 21:15:34 +0800

## Raw message

```
{% raw  %}From: Secret Squirrel<EMAIL_ADDRESS>Date: Thu, 29 May 1997 21:15:34 +0800
To<EMAIL_ADDRESS>Subject: pathology
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

This was taken from the Alameda County District Attorney's Office
publication "The Point of View":

In a murder trial, the defense attorney was cross examining a pathologist.

CORONER:   No.
ATTORNEY:  Did you listen to the heart?
CORONER:   No.
ATTORNEY:  Did you check for breathing?
CORONER:   No.
ATTORNEY:  So, when you signed the death certificate, you weren't sure the
           man was dead, were you?
CORONER:   Well, let me put it this way.    But I guess it's possible he could be out there
           practicing law somewhere.

{% endraw %}
```

## Thread

+ Return to [May 1997](/archive/1997/05)

+ Return to "[Secret Squirrel <nobody@secret.squirrel.owl.de>](/authors/secret_squirrel_nobody_at_secret_squirrel_owl_de_)"

+ 1997-05-29 (Thu, 29 May 1997 21:15:34 +0800) - pathology - _Secret Squirrel<EMAIL_ADDRESS>