text:
## Register your Mirror as Google Assistant related device
You might need to register your mirror as device of Google Home/Assistant App. (For more control or gAction using)

Follow this.
```
cd ~

sudo apt-get update

sudo apt-get install portaudio19-dev libffi-dev libssl-dev libmpg123-dev

sudo apt-get install python3-dev python3-venv

python3 -m venv env

env/bin/python -m pip install --upgrade pip setuptools wheel

source env/bin/activate

python -m pip install --upgrade google-auth-oauthlib[tool]

cp MagicMirror/modules/MMM-AssistantMk2/credentials.json .
```
Then,
```
google-oauthlib-tool \
  --scope https://www.googleapis.com/auth/assistant-sdk-prototype \
  --headless --client-secrets credentials.json
```

This will display some URL. Copy it and paste it into browser. You will be asked some confirmation, then, you can get some CODE. Copy it and paste into terminal then enter.
Then, You will get some code similar this;

```
{
   "scopes": ["https://www.googleapis.com/auth/assistant-sdk-prototype"],
   "token_uri": "https://accounts.google.com/o/oauth2/token",
   "token": "ya29.GlujBLa_kuXZ5GnGBPBe_A6NpczLcpOtglEC0wHVORnmEhHETzlSW",
   "client_id": "795595571889-6iesr9a3nkmnipbdfnqi6gehiklm2m28.apps.googleusercontent.com",
   "client_secret": "Un8_TNFnb55555auSAGasvAg",
   "refresh_token": "1/4ZMBhTR3bTYWVEMatYWLOxW755555hlQXZI5uC02F2U"
 }
```
Copy the token (exclude quotation mark) Then, type in the shell like this.
```
ACCESSTOKEN=<Paste your copied token here>
```
> Don't add `<` and `>`. So, it looks like `ACCESSTOKEN=ya29.GlujBLa_ku...`

Now create “deviceInstance.json” (sample is on your MMM-AssistantMk2 directory)
```
nano deviceInstance.json
```
and write this and save.
```
{
    "id": "my_mirror_001",
    "model_id": "YOUR_MODEL_ID",
    "nickname": "My 1st Mirror",
    "client_type": "SDK_SERVICE"
}
```
`id` is `instanceId`, so you can name it as your wish like `MY_2ND_MIRROR` or `RPIONBEDROOM` or anything else.

`YOUR_MODEL_ID` could be got from your Google Project console. (You've already got this and `YOUR_PROJECT_ID` when your project was created.)
Then,
```sh
curl -s -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer $ACCESSTOKEN" -d @deviceInstance.json \
https://embeddedassistant.googleapis.com/v1alpha2/projects/YOUR_PROJECT_ID/devices/
```
 If success, your contents of deviceInstanc.json will be displayed again.
 Now, `my_mirror_001` is your deviceInstanceId

Then, modify configuration of MMM-AssistantMk2, and rerun.
```js
deviceModelId: "YOUR_MODEL_ID",
deviceInstanceId: "my_mirror_001",
```

Now you can see your mirror on Google Home App in your phone.

url: https://raw.githubusercontent.com/DanSWallace/MMM-AssistantMk2/6bc90a55ecc634fe94f41da34a00b89679ec46d0/wiki/Register your Mirror as Google Assistant related device.md


text:
# Example 2: syncing two peers via UDP (on the same machine)

## Start configuration

Alice has 9 events in her log, plus 7 from Bob in 2.pcap:

```text
alice$ for i in logs/*; do C=`../dump-log.py $i | grep "{ 'app" | wc | cut -c 5-10`; echo $C $i ; done
9 logs/1.pcap
7 logs/2.pcap
alice$
```

Bob has 7 events in his log, and none from Alice:

```text
bob$ for i in logs/*; do C=`../dump-log.py $i | grep "{ 'app" | wc | cut -c 5-10`; echo $C $i ; done
7 logs/1.pcap
bob$
```

## Alice starts UDP Peer-to-Peer replication, as a responder

```text
alice$ ../udp-peer.py
Welcome to SneakerNet

** starting replication tool
** peer-to-peer responder
** waiting on UDP port 4097

```

## Bob starts UDP Peer-to-Peer replication, as a initiator

```text
bob$ ../udp-peer.py <IP_ADDRESS>
Welcome to SneakerNet

** starting replication tool
** peer-to-peer initiator: connecting ...
** talking to ('<IP_ADDRESS>', 4097) (responder), my UDP push_port is 5000
-- incoming cmd: b'PORT 4098'
-- incoming cmd: b'HAVE +TOLr0m0rwAhop64A6RW4tn8bwKQFZrNgPUV4S4umCB4=:7 +SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:9'
-- incoming push: 269 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:1
-- incoming push: 270 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:2
-- incoming push: 270 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:3
-- incoming push: 270 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:4
-- incoming push: 270 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:5
-- incoming push: 270 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:6
-- incoming push: 270 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:7
-- incoming push: 271 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:8
-- incoming push: 271 bytes
-- ingested event SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:9
** peer_loop done
bob$
```
Explanation:
- <IP_ADDRESS> means that responder and initiator run on the same machine (for this demo). In a LAN, this should be replaced with the IP address of the responder machine
- the handshake was successful (not shown in output)
- Bob received a PORT command, saying where-to he should send events
- Bob received from Alice a HAVE list (which feeds and their max sequence)
- in the background, Bob saw that he is missing Alice's feed SPQMT3a...
- in the background, Bob tells Alice what he WANTs
- then 9 events arrive at Bob's push port
- after 5 seconds of silence, the initiator software ends

## Continuation of Alice's output, once Bob connected:

```text

** talking to ('<IP_ADDRESS>', 4099) (initiator), my UDP push_port is 4098
-- incoming cmd: b'PORT 5000'
-- incoming cmd: b'HAVE +TOLr0m0rwAhop64A6RW4tn8bwKQFZrNgPUV4S4umCB4=:7'
-- incoming cmd: b'WANT +SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:1'
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:1
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:2
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:3
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:4
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:5
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:6
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:7
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:8
-- enqueue outgoing push for SPQMT3aGl9QRDYZCzv8oKC0QYp62XP5DiFTDKIzsaH4=:9
** peer_loop done
** waiting on UDP port 4097

```

Explanation:
- the handshake was successful (not shown in output)
- Alice received a PORT command, saying where-to she should send events
- Alice received from Bob a HAVE list - boring because she already has it
- Bob says what he WANTs
- Alice prepares 9 events to be sent
- after 5 seconds of silence, she goes back into waiting mode

---

license: MIT

repository: cn-uofbasel/BACnet

branch_name: refs/heads/master

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive

repo_name: cn-uofbasel/BACnet


text:
Archive
======

Completed tasks can be moved to Archive from the boards or by using the **Actions** button in task window. It is a convenient method of keeping a history of tasks as well as a reference to restore any archived tasks.

![Archive task](archive_task.png)

You can always restore tasks from the archive in case of a necessity. Simply click on the **Restore** button in the specific task window.

![Archive task](restore_archive.png)

The list of archived tasks can be filtered by partner or project.

![Archive List](archive_filter.jpg)

repository: Denis-SPL/docs

repo_name: Denis-SPL/docs


text:
---
date: "2021-04-01"
edition: "2021q2"
intro: "Welcome to the 2021 Spring edition of the FreeSewing newsletter. Here's what we have included for you:"
title: "2021 Spring edition"
---

Welcome to the 2021 Spring edition of the FreeSewing newsletter.
Here's what we have included for you:

- 👕 Pattern releases winter 2021 (1-minute read - by Joost)
- 🕵 Behind the seams: Wouter van Wageningen (9-minute read - by An & Wouter)
- 🔍 Spotlight on some lesser-know FreeSewing features (3-minute read - by Joost)
- 🤯 Some of the more crazy ideas on our drawing board (3-minute read - by Joost)
- ❤ FreeSewing is brought to you by the kindness of strangers (5-minute read by Joost)

We hope you enjoy it.
If not, mash that reply button and tell us what you'd like to read instead ¯\\\_(ツ)\_/¯

# 👕 Pattern releases winter 2021

Here's a quick recap of the new patterns we released in the first quarter of this year:

 - [The Bella bodice block for womenswear](https://freesewing.org/blog/bella-bodice-block/): A collaboration with somebody from the industry to replicate the kind of bodice block that's used in fashion today. Currently it has a bust dart towards the side-seam. A variation with a shoulder dart is on our todo list.
 - [The Hortensia handbag](https://freesewing.org/blog/announcing-hortensia/): Another collaboration, this time between Stofsuchti and long-time contributor Wouter Van Wageningen brought the first handbag pattern to FreeSewing.
 - [The Cornelius cycling breeches](https://freesewing.org/blog/cornelius-cycling-breeches/): More from Wouter still, these cycling breeches or knickerbockers are based on the Keystone drafting method.

Click through any of the links for the blog posts announcing these patterns.

---

# 🕵 Behind the seams: Wouter van Wageningen

> *With two pattern releases to his name in the last 3 months,*
> *who better to shine a spotlight on than long time contributor Wouter.*
>
> *An — one of our newer contributors — interviewed him for this newsletter:*

## Bio

Born in the Netherlands and lived there for 30 years before moving to “the States”.
He accompanied his American wife when she wanted to return and has been living there for
over 20 years. He now considers it his home, while recognizing all the emotional ties to
The Netherlands when he goes back to visit.

While a busy IT manager, he likes to create new patterns for FreeSewing from time to time.

## How did you learn about freesewing?

When I started sewing many years ago, I was continuously looking for patterns for men.
The site of Joost, Makemypattern (since late 2012), came up in one of my searches, and
I thought it was an interesting concept.

## How did you become a contributor?

In the beginning, there were no contributors other than Joost, that I remember. He had
made this framework that allowed other people to make patterns that could be incorporated.
Being a programmer, as a professional and hobbyist, this intrigued me. The originally site
was created in the PHP programming language, one I had not worked with before. I thought
this made for an interesting challenge to contribute to the work of Joost.

As this was my first experience with the toolset, the language, and making patterns,
I picked something as easy as [a bow tie](https://freesewing.org/designs/benjamin/).
It is a simple object, as it is flat with a width and a height, but no real depth.
Therefore, I didn’t have to try to shape a piece of fabric around a 3D shape. The result passed the muster of Joost, and became an official pattern on the site.

Before finding FreeSewing, I had drawn a pencil skirt for my partner by just using
her measurements. I realized while working on the bow tie that I could try to combine
the experience of making this skirt with that of making the pattern for the bow tie, and
make another pattern for FreeSewing.
Thus, [the Penelope pencil skirt](https://freesewing.org/designs/penelope/) was born.

## What has been your contributor work so far?

I have created [the Waralee wrap pants](https://freesewing.org/designs/waralee/),
[Albert apron](https://freesewing.org/designs/albert/), and [Cornelius cycling breeches](https://freesewing.org/designs/cornelius/).
I also did the implementation of [the Hortensia handbag](https://freesewing.org/designs/hortensia/), but that is not my design. I got the drawings and measurements from the designer (Stoffsuchti), and translated those
into a FreeSewing pattern.

The Benjamin bow tie was totally my own creation, exactly as I imagined what it should look.
The Penelope and Waralee designs were built from the knowledge I gathered by reading about those types of garments, and implementing my interpretation of them.
The Cornelius is actually an implementation of a pattern in an existing drafting system (The "Keystone" System).

## When and why did you start sewing?

Seven or eight years ago, I wanted to know what it would be like to wear a kilt. But
kilts are insanely expensive. They are made of very nice wool and it takes an enormous amount of time to make a real Scottish kilt. There are these “utility kilts”, which are basically cargo pants made into a kilt. More
practical with pockets, and made out of cotton, but they still cost around $200.

Because I was still figuring out whether I would enjoy wearing a kilt, it didn't make much sense to me to invest that much. While researching this I found [a website dedicated to people wearing kilts](http://www.xmarksthescot.com/), and it had a documented process on how to create your own utility kilt.
I did have a sewing machine, it seemed within my abilities, so I bought some fabric and started sewing.
One kilt became two, and then I figured I needed a shirt to go along with it. It should be somewhat
contemporary to old kilts. With a little searching I found a pattern to make such a shirt. And that led to making more and more shirts, and then pants and...

At one point I decided that I wasn't going to buy any more clothes, I was just going to make them.
One exception to that are underwear and socks, as these don’t give me much pleasure in making them, and are usually ridiculously cheap. I have knitted a pair of socks, and I like knitting a lot. I just don't seem to be able to knit fast enough to keep up with the wear and tear.
The other exception is athletic or technical clothing, as I just cannot buy the fabrics (e.g. eVent) you need for it.
These are exclusively sold to vendors of this type of clothing. I have recently made some yoga pants and biking shorts for myself, so this may change.

## What is your daily job, outside of freesewing?

IT manager. I take care of the IT needs for a union of homecare workers.

## What are you currently working on?

Nothing for FreeSewing at the moment, but I am looking into the possibility to make a pattern based
on the trouser block. That way, I don't have to start from scratch as I usually do, and just extend
Joost's work. I'm looking forward to trying this approach, but I first have to complete my doublet.

## Which project did you just finish?

The [Cornelius cycling breeches](https://freesewing.org/designs/cornelius/) and the implementation of [the Hortensia handbag](https://freesewing.org/designs/hortensia/).

## What sewing project are you most proud of?

I'm proud of a lot of projects; my first shirt (even though it has a lot of faults), my first tailored coat, all of my art shirts, …
But if I had to pick one, it would probably be [my Mondrian shirt](https://shirtartistry.blog/2019/01/23/mondrian-shirt-the-beginning/). It was the one where I went all the way from a concept in my mind, though creating it on paper, to turning it into a garment.

Everybody will answer that with something like 'my children'. And I am proud of the persons they've become.
But I think that is more something they have done, than what I have done. I was just there to help
them when needed. One of the things I've done that I'm proud of is having been a volunteer firefighter for 10 years.
And, for the last 20 years or so, I've worked for nonprofits trying to make the world a better place.

## What do you love the most about sewing?

The creativity. I like to make things. I discovered that with sewing, in contrast to things like wood or metal working, I can be really precise. And I can find the patience in myself to create that precision.
What’s more, if I make a mistake, I can usually undo it (e.g. take the seam out). It's a lot harder to take things apart once you've glued them together.
I also like that I can make something that is a flat drawing on a piece of paper into something that is a
real three dimensional thing, by turning those patterns into pieces of fabric and sewing them together.
Even the trail and error process to adapt a pattern to my needs, or to create a new pattern from scratch, is interesting to me. It's a discovery journey with practical outcomes.
And, although I'm not good at all of the required skills, I can do most of them well enough that I can go from something in my head to something that I can wear, and that is very satisfying.

## What do you hate the most about sewing?

I am a bit too impatient to do large parts of sewing by hand, and that is my least favorable part of sewing. The occasional basting is fine, it is the sewing of a full seam by hand that is beyond me.
I have made buttonholes by hand on my tailored jacket, and that was satisfying by itself. Yet it takes too much time
and it doesn't fascinate me enough to allow me to become good at it. It'll most likely take a long time before I’ll do it again. For some reason I don't mind doing the pad stitching for lapels and such on tailored jackets.

## What’s the hardest part of sewing to you?

 I'm really
bad at drawing free form. Because of this, I cannot, not even temporarily, put the end result of a certain clothing design on a piece of paper to look at it. And therefore I cannot get someone else’s opinion or input on it
before I create it. It is frustrating.

## What would be your advice for starting sewists/sewistas?

First of all, go for it and concentrate on the parts of the sewing process you enjoy. Look at the big
picture of creating a garment for yourself, and let that motivate you to get through the parts you
don't like so much.

Secondly, just keep going and don’t look at things that didn't work out so well too much. Everything
takes practice, and you will get better at it. Break up things into smaller parts and think about
what you can do to improve that one part. Maybe there's a different way to do this step that works
better for you.

Lastly, don’t be intimidated by patterns. Try different patterns, designers, and techniques. Pick out what works for you. All designers have their own way of doing certain things, and they may not always align with your strengths and weeknesses. I always
do a zipper fly the same way, regardless of what the designer suggested. My way works for me and
gives me good results. Others may prefer other techniques, so find your own by trying a lot of different ways.

And most of all; enjoy the process of creating. The end product is an additinal benefit. Through the enjoyment of the process, you will gain the experience to get good at it. And with that, you will get the garments you like.

## Are you married?

Not anymore, after 25 years we amicably split up. I have a new partner now.

## Do you have children?

Five in total, two adult children of myself and three almost adults of my partner.

## Do you have pets?

I have had three dogs. I would enjoy having a dog, but my current life style and freedom to travel does not match up with having one.

## If there was one thing you could take with you to an uninhibited island what would it be? Why?

A knife, because it seems to be the most useful item to help me survive.

## If there was one person you could take with you to an uninhibited island, who would it be? Why?

Nobody, since I could not forgive myself for putting someone else through the same ordeal.
I love what thousands of years of society has brought us, and I don't want to be without its fruits. So it would be cruel for me to subject someone else to this punishment.

---

# 🔍 Spotlight on some lesser-know FreeSewing features

Regardless of whether you've only recently discovered FreeSewing, or have been a user for many years, here are some things you might not have discovered on your own:

## Multilingualism

FreeSewing is available in 5 languages, each with their own website. In addition to [English at freesewing.org](https://freesewing.org/), we have websites in [French](https://fr.freesewing.org/), [German](https://de.freesewing.org/), [Dutch](https://nl.freesewing.org/), and [Spanish](https://es.freesewing.org/).

If you'd like to help us add more languages, [get in touch](https://discord.freesewing.org/).
## Paperless patterns

Not a fan of printing and sticking pages together? Or perhaps you don't have a printer? Don't despair, because FreeSewing provides **paperless patterns**.

You'll find the **paperless** option under the **Pattern options**. Flick it on and now you'll have dimensions as well as a grid in either metric or imperial so you can transfer your pattern directly to fabric or another medium like pattern paper.

## Custom layout/tiler

Laying out the different pattern parts on your pattern happens automatically. But alas, it's one of those things that computers are far worse at that humans.  If only you could, right?

Turns out you can. Simply **Export** your pattern as **SVG** and fire up **Inkscape** (which you can [download for free](https://inkscape.org/)).

When you open the pattern in Inkscape, the entire pattern will be in a *group*, so first thing to do is to **select** it and **right-click** and choose **ungroup**. Now you can rotate and flip each part around and arrange them just as you like. When you're happy, click **File** -> **Document properties** and choose **Resize page to content**.

When you're done, save the SVG and upload it to our custom tiler: https://tiler.freesewing.org/
There you can upload the SVG and pick your page size, and you'll get a PDF just like on the  website. Only this time, with your own layout 👍

## Remove details from a pattern

This option was originally intended for laser cutters, but has other uses too.

For this, you'll have to enable so-called **Expert mode**. Under **Pattern options**, click **Expert mode** and set it to **Show**.
Now, you'll have the **Advanced** option under which you'll find **Detail**. If you set it to **Hide**, your pattern will not only show the outline of the different pattern parts.

This is also handy for when you are making doll clothes as the titles, logo, and size box end up being taking up more space than the pattern itself.

## Include only certain pattern parts

Since we've unlocked **Expert mode**, here's another tip you mightn't be aware of: the **Contents** option. This option allows you to not draft the entire pattern, but only those parts that you want.

This can be handy if you want to make a change to a pattern and only print those parts that are affected. But also if you want to combine different styles. For example you can generate a complete Simon pattern, and then additional collar or cuff styles where only the collar/cuffs are included in the pattern.

Got an idea for some other cool feature you'd like to see? Make sure to [let us know](https://discord.freesewing.org/).

---

# 🤯 Some of the more crazy ideas on our drawing board

We're rarely stuck for things to do, because some work is never finished: adding more patterns, writing more or better documentation, improving user experience, and so on.

 Here's a selection of them that we've been mulling over. Don't consider it a sneak preview though, some of these are bona fide moonshots:

## Allowing users to create their own pattern layouts on the site

The pattern layout — the way the individual pattern pieces are laid out on the page — seems like the low-hanging fruit of improvements. Almost without exception, your pattern will not be the most optimal layout.

Thing is, computers are not very good at this sort of spacial problem that's called *packing*. We could try to tweak the algorithm, but human beings are just intuitively better at it than computers are.

**The goal**
To make it possible (and ideally easy) for people to do their own layout. So that before you export your pattern, you have the option to arrange it just as you like it.

**What it would take**
This is something that's been on the drawing board for quite some time. FreeSewing core already has support for custom layouts, so it's really *just* a matter of creating the frontend interface to handle the layouting.

**Roadblocks**
Doing the SVG layout on mobile is a minefield.

**Chances of this happening**
High. We're almost certainly going to do this at some point.

## Using 3D renders to showcase patterns or options

3D in general is something we have our eye on, but in this case it's really about presenting the patterns to the user. People want to know what they're going to get, and line drawings and showcases can only go so far to show that.

The idea would be to be able to show patterns on a 3D avatar. However, a big caveat is that we would have to be able to somehow automate this process since we can't go manually creating a 3D render of every pattern & option.

**The goal**
Create 3D renders of different patterns and the effect of pattern options. Integrating this with our build pipeline so those renders can be auto-generated.

**What it would take**
Some work has been done already. Last year we wrote a DXF-exporter plugin that can export patterns as DXF, a popular format in 3D tools. We did some initial tests with CLO3D but the lack of automation options not to mention the fact that it's a closed-source commercial product made us abandon that path.

The right thing to do would be using Blender so that this work would benefit the open source community.

**Roadblocks**
Blender is not that easy to learn. Automation and plugins in Blender need to be written in Python, and we're a JavaScript project. Basically, we have nobody who knows how to even start on this today.

**Chances of this happening**
Medium. Could really use some help on this.

## Frankenstein patterns

The name *Frankenstein pattern* is something that came up during one of our contributor calls, and the name sort of stuck. The idea is that you could mix and match parts from different patterns to create your own combinations. Like, pick a top and combine it with the sleeves from another top and perhaps the collar from yet another top.

**The goal**
Allow patterns to be created by combining different building blocks.

**Roadblocks**
This would require some sort of inter-pattern API or interface specification.

**Chances of this happening**
Low. For pattern developers, combining parts from different patterns is already possible via inheritance. Exposing this sort of functionality to the user level would already be a significant challenge. But doing it in a way that requires no code and merely some clicking around is pretty far out there.

---

# ❤ FreeSewing is brought to you by the kindness of strangers

On April 5th 2011, a Tuesday of all days, I published a sewing pattern on my blog.
BXR-M01A was a pattern for boxer briefs that came in one size only, and was free to download under a Creative Commons license.

It was also the very first pattern I ever published.

The event as such doesn’t deserve much attention, but it just happens to have occurred 10 years ago — almost to the day.
So it seemed a good starting point for a brief history of how we got from there to here.

## The Early Days

I started drafting my own sewing patterns because I had fitting issues with store-bought ones.
Drafting my own patterns held the promise of flawless fit with just a bit of effort (Oh, how naive I was!).
The fiddling about with paper had me bored in no time, so I set out to try to automate that part of the process.
I came up with a way to reduce the pattern to a number of steps, and abstract away the measurements.
Now, you could feed it whatever measurements you wanted, and it would re-draft the pattern for you.

I launched the beta version of my little pattern machine in February of 2012.
It wasn’t an immediate success.
As a matter of fact, to the best of my knowledge, only one person ever tested it.
That person was Nico in Copenhagen (who I've sadly lost track of) who wrote:

> *That is sooo cool.*
> *I will enter my thoughts about your project using your feed back thingy on the pattern web site.*
> *But you should know that the overall fit is amazing! I think I have a new favourite pattern :-)*

## makemypattern.com

One good review is perhaps not much to go on, but I found it rather encouraging and set out to walk this path a bit further.
Fast-forward six months and I’d rewritten the thing from scratch, and with four patterns available officially launched makemypattern.com in September of 2012.

Things sort of trickled along as I added a pattern every now and then.
Then, in January 2014 I got an email from Tin Doan in Canada asking how they could donate to the site.
I sort of expected this to be some sort of scam, but I still answered the email asking “Are you for real?”. Tin answered:

> *Yes Joost, I'm serious. Please kindly accept $200.00 from me.*

Sure enough, I soon found myself at the receiving end of a $200 donation.
To this day, it remains the highest amount I've ever received in a single donation.

This unexpected yet very tangible token of support felt like a fork in the road.
I'd been happy building this thing mostly as a learning experience.
Now it felt like perhaps it needed a bit more devotion and care.

In retrospect, this point probably marks the end of my social life 😂 good thing I had found a partner by now (phew).

## Pivot to Open Source and freesewing.org

So of course I rewrote the whole thing — again — into what would turn out to be the last version of makemypattern.com.
By the summer of 2016, five years after my first pattern release, and four years after launching makemypattern.com,
my little hobby project had made a lot of headway, and I found myself at another turning point:
Keep doing what I'm doing, or try to break through the next barrier.

Up until this point, I had been doing makemypattern.com on my own.
The code wasn’t even available. I wanted to make it into an open source project that people could contribute to.
But I had never started it with that ambition, and it was going to take some serious refactoring
to make it into something that people would be able to wrap their heads around.

So I did exactly that, and in March 2017 I launched v1.0.0 of freesewing.org.
A new name (and logo) to mark the transition to an open source project.
This was a much more mature release, with a documented API and it led to the first patterns contributed by others.
It also came with a hat I hadn't worn before, open source maintainer.

## FreeSewing v2.0.0: It's JavaScript Now

During all this time, the world of frontend development had changed and we could do so much more in a browser.
Rather than picking a bunch of options and getting a pattern in the end, the idea of seeing
the pattern update in your browser as you changed options was — at least in theory — attainable now.

With that goal in mind, I started over again, this time in JavaScript.
And in August of 2019 v2.0.0 landed on freesewing.org.
A complete rewrite in JavaScript with a new website to boot.

Since then, I've been able to keep myself from rewriting the entire thing again 🤞

## The Family You Choose

We're getting closer to present time, but there's one more moment that stands out for me,
and that's a blog post from August 2020 where — maybe for the first time — I explicitly asked for help to grow the project.
Since then, a community has developed around FreeSewing that feels more valuable to me than any code I could ever write.

Motivation is a powerful thing, and I wonder whether FreeSewing would exist today if it wasn't for the full-on enthusiasm of Nico in the early days.
Or whether it would have fizzled out without Tin injecting some rocket fuel in the form of a donation.
Or whether perhaps I would have succumbed to burnout by now if I hadn't found such a great group of people to walk this road with me.

Speaking of which: There are countless individuals who have contributed to get to where we are today.
I couldn't possible mention them all. But what they have in common is that at one point, they were complete strangers to me, as I was to them.

It’s the kindness of strangers that brought us here.

Thank you strangers.

repository: freesewing/freesewing

branch_name: refs/heads/develop

gha_language: JavaScript

repo_name: freesewing/freesewing


text:
---
aliases: []
---

Contributions are very much welcomed. The easiest way to get started is to join the [[Discord]] server to get talking! Here are some ways to help:

## Designing Semantic Obsidian plugins
Ideally, the features of the [[Neo4j Graph View Plugin]] and other [[Semantic Obsidian]] related plugins would be designed with the Obsidian community. Input is very much welcome, especially on features mentioned on the [[Roadmap]]. The best way to help here is by joining the [[Discord]] server.

## Contributing to this vault
This vault is publicly available at https://github.com/HEmile/semantic-obsidian. If you know of a cool way to contribute, for example by writing or improving a guide or sharing something cool you made with a plugin, please submit a pull request!
If you do, please add - author \[\[\]\] links to your profile.

## Help developing Semantic Obsidian
If you know some programming, help is definitely appreciated! See the [[Roadmap]] for possible features to help on, or submit a pull request to the github repo https://github.com/HEmile/semantic-markdown-converter .

---
#development
- hasTopic [[Semantic Obsidian]]
- author [[Emile van Krieken]]

path: /Semantic Obsidian/Contributing.md

branch_name: refs/heads/main


text:
---
layout: default
modal-id: 1
date: 2015-05-08
title: Why Direct Air Capture
img: intro.png
alt: image-alt
project-date: April 2014
client: Start Bootstrap
category: Web Development
description: Over 25% of carbon dioxide emissions come from the transportation sector where fossil fuel dependence is very strong.  While electrification of the car and truck fleet will help mitigate the amount of CO2 being released by this sector, electrification will take some time to implement and in some cases isn’t feasible (aka air travel).  Thus it is not unreasonable to think that there will continue to be a large distributed release of CO2 into the atmosphere from transportation which due to its distributed nature cannot be addressed like point sources with traditional CCS solutions.  The only solution to mitigate the CO2 emissions from these distributed sources is direct air capture of CO2.

---

extension: markdown


text:
+++
title = "This Week In Veloren 192"
description = "Meeting minutes and tracking issues"

date = 2022-10-03
weight = 0
slug = "devblog-192"

[extra]
banner = "https://cdn.discordapp.com/attachments/634860358623821835/1025274327169511434/screenshot_1664514633785.png"

[taxonomies]
tags = ["devblog"]
+++

This week, we watch a certain jumping plumber.

\- Christof, TWiV Contributor

# Contributor Work

Thanks to this week's contributors, @xMAC94x, @fanix472, @aweinstock, @juliancoffee, @meyerhenning, @ztianyang.

## Tracking issues in the book by @zesterer

I added a page to the book that lists all of the currently open tracking issues. I hope this will act as a useful resource for contributors looking to work on things, and hopefully it'll encourage us to improve the quality of our [tracking issues](https://book.veloren.net/contributors/tracking-issues.html#tracking-issues)!

See also [this week's developer meeting minutes](https://hackmd.io/DxpRFzx6Rxav81DDg8ltSA) for more details.

## Super Veloren 64

Also @zesterer created a cool tech demo because he "was bored today":
{{ youtube(id="iSg3KpQvzUw") }}

## Translation changes by @Juliancoffee

Me and @xMAC94x made some changes to how chat is translated and introduced the new i18n-helpers crate. For the time being it lies in voxygen workspace.
It enables third-party clients to use localisation (and translations, if desired) via the client/i18n subcrate.

And with that we now have the possibility to work on more complex translations, like character names and items.
Until that point, we could translate mostly GUI only (+ some npc messages).
If you want to work on it, ping me @juliancoffee in #new-contributors

{{
    img(src="https://cdn.discordapp.com/attachments/634860358623821835/1025486531609247764/screenshot_1664565398532.png",
    caption="A diverse group. See you next week!")
}}

{{ support() }}

repository: veloren/site

repo_name: veloren/site


text:
[Return to Presets](./README.md#bracketed-segments)

# Bracketed Segments Preset

This preset changes the format of all the built-in modules to show their segment in brackets instead of using the default Starship wording ("via", "on", etc.).

![ڕوونماوێنەی پێشڕێکخستنی Bracketed Segments](/presets/img/bracketed-segments.png)

### ڕێکخستن

```sh
starship preset bracketed-segments -o ~/.config/starship.toml
```

[Click to download TOML](/presets/toml/bracketed-segments.toml)

<<< @/.vuepress/public/presets/toml/bracketed-segments.toml

license: ISC

repository: starship/starship

gha_language: Rust

gha_license_id: ISC

repo_name: starship/starship


text:
C# Design Meeting Notes for Mar 4, 2015
========================================

Discussion on these notes can be found at https://github.com/dotnet/roslyn/issues/1303.

Agenda
------

1. `InternalImplementationOnly` attribute <*no*>
2. Should `var x = nameof(x)` work? <*no*>
3. Record types with serialization, data binding, etc. <*keep thinking*>
4. "If I had a [billion dollars](http://www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare)...": nullability <*daunting but worth pursuing*>

1. InternalImplementationOnly
=============================

This was a last-minute proposal for C# 6 and VB 14 to recognize and enforce an attribute to the effect of disallowing non-internal implementation of an interface. It would be useful to represent "abstract hierarchies", while reserving the right to add new members at a later stage.

Conclusion
----------

Let's not do this. We cannot enforce it well enough since old compilers don't know about it.

2. Should `var x = nameof(x)` work?
===================================

This was raised as issue #766.

``` c#
var POST = nameof(POST);
```

Conclusion
----------

This works the same as with any other construct, i.e.: not. This is not a special case for `nameof`, and it doesn't seem worth special casing to allow it.

3. Records
==========

There's general excitement around proposals such as #206 to add easier syntax for declaring "records", i.e. simple data shapes.

This discussion is about the degree to which such a feature should accommodate interaction with databases, serialization and UI data binding.

The problem has compounded in recent times. In a mobile app, pretty much everything has to be serialized one way or another. There's a big difference between e.g. JSON and binary serialization. In one you want readable property names (in a certain format), in the other you want compactness. ORMs are also essentially serialization. POCO was invented in that same context, but only gets you part of the way there.

Clearly, tying the language feature to specific such technologies is not a sustainable idea. There will not be built-in JSON literals, or `INotifyPropertyChanged` implementation or anything like that.

That said, It is worth thinking about what can be done *in general* to support such features better.

One problem is that each specific serialization and data binding technology tends to have certain requirements of the shape of the data objects. Serialization frameworks may expect the fields to be mutable, or to have certain attributes on them. UIs may expect properties to notify on change. Such requirements make it hard to have a single language-sanctioned mechanism for specifying the data shapes.

A separate problem may be the degree to which reflection is used by these technologies. It is commonly used to get at metadata such as member names, but is also sometimes used to set or get the actual values. It ends up being the case that both serialization and UI use the objects only in a "meta" fashion; the only part of the program that actually makes use of the data in a strongly typed way ends up being the business logic in between.

So in effect, data objects need to both facilitate strongly typed business logic based on their property names and shapes (and often in hierarchies), *and* satisfy requirements that are specific to the serialization and UI environments they are used in. Cross-cutting aspects, one might say, that clash in the implementation of the data objects.

There are several possible approaches, not necessarily mutually exclusive:

**Write the data types manually**: Often what ends up happening today. Just grit your teeth and churn out those INotifyPropertyChanged implementations.

**Separate objects**: Often the "best practice" is to have separate objects for serialization, logic, and presentation. But having to write the glue code between these is a big pain, and people often have to do at least some of it manually.

**Non-reflective meta-level access model**: E.g. implement dictionary-like behavior. Prevents need for reflection, but is it actually better or faster?

**"Fake" types**: Maybe at runtime the data objects shouldn't have strongly typed properties at all. Maybe the business logic is written up against a new kind of types that are only there at compile time, and which either simply erase like in TypeScript, or cause weakly typed but smart access code to be generated like with F# type providers. Then, from the perspective of serialization and UI, all the objects have the same type.

**Compile-time metaprogramming**: Generate the types (either into source or IL) from code describing the data shapes, adding whatever serialization or presentation functionality is required.

A particularly common requirement of these frameworks is for the data properties to be mutable. That might clash spectacularly with a records feature that tries to encourage immutability by default.

Conclusion
----------

We'll keep thinking about this situation. A next step in particular is to reach out to teams that own the serialization and presentation technologies that we'd like to work well with.

Nullability and reference types
===============================

The horrifying thing about null being allowed as a member of reference types is that it does not obey the contract of those types. Reference types can be null *and* reference types can be dereferenced, But dereferencing null is a runtime error! No wonder Sir Tony famously calls null pointers his "[billion dollar mistake](http://www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare)".

There are type systems that prevent null reference errors, and it is easy enough to do. It takes different shapes in different languages, but the core of it is that there is a non-nullable kind of reference type that can be dereferenced but cannot be null, and a nullable "wrapper" of that, which *can* be null, but cannot be dereferenced. The way you go from nullable to nonnullable is through a guard to test that the nullable value wasn't in fact null. Something like:

``` c#
string? n; nullable string
string! s; non-nullable string

n = null; // Sure; it's nullable
s = null; // Error!

WriteLine(s.Length); // Sure; it can't be null so no harm
WriteLine(n.Length); // Error!
if (n is string! ns) WriteLine(ns.Length); // Sure; you checked and dug out the value
```

Of course, if such a type system were around from day one, you wouldn't need the `!` annotation; `string` would just *mean* non-nullable.

It's a very common request (in fact [the top C# request on UserVoice](http://visualstudio.uservoice.com/forums/121579-visual-studio/category/30931-languages-c)) for us to do something about null reference exceptions along those lines. There are numerous obstacles, however:

**Backward compatibility**: The cat is already very much out of the bag in that existing code needs to continue to compile without error - no matter how null-unsafe it is. The best we can do about *existing* code is to offer optional analyzers to point out dangerous places.

**A default value for all types**: It is deeply ingrained in .NET and the CLR that every type has a default value. When you create an array with `new T[10]`, the array elements are initialized to the default value of `T`. There's even syntax to get the default value of a type, `default(T)`, and it is allowed even on unconstrained type parameters. But what is the default value of a non-nullable reference type?

**Definite assignment of non-nullable fields is unenforceable**. Eric Lippert explains it well [on his blog](http://blog.coverity.com/2013/11/20/c-non-nullable-reference-types/).

**Evolving libraries is breaking**: Say we added non-null annotations to the language. You'd then want to use them on your existing libraries to provide further guidance to your clients. Adding them on parameters would of course be breaking:

``` c#
public void Foo(string! name) { ... } // '!' newly added

Foo(GetString()); // Unless GetString also annotated, this is now broken
```

More subtly, adding the extra guarantee of non-nullability to a *return* type would also be breaking:

``` c#
public string! Foo() { ... } // '!' newly added

var s = Foo(); // Now infers 'string!' instead of 'string' for s
...
s = GetString(); // So this assignment is now broken
```

Type inference and overload resolution generally make strengthening of return types a potentially breaking change, and adding non-nullability is just a special case of that.

Conclusion
----------

Moving C# to a place of strong guarantees around nullability seems out of the question. But that is not to say that we cannot come up with an approach that meaningfully reduces the number of null reference exceptions. We want to keep digging here to see what can be done. The perfect is definitely the enemy of the good with this one.

path: /docs/designNotes/2015-03-04 C# Design Meeting.md

filename: 2015-03-04 C# Design Meeting.md

gha_language: C#


text:
# Docstring Writer
A docstring writer for Python files written in Python.

## What?
It automatically generates docstrings for functions and classes in Python
scripts.

## How?
Using the AST (*Abstract Syntax Tree*), it finds the arguments, attributes,
returned/yielded variables and raised exceptions and formats them, mostly
following the
[Google Python Style Guide](https://google.github.io/styleguide/pyguide.html).

## Can it replace me as the human?
No, because you still have to write descriptions that describe what the
functions do. Good documentation shows not only what variables are being used
but how and why they are being used as well.

## Can you give an example?
Yes.

## ...Give me an example.
**Running it:**

```
$ python3 doc_writer.py boop.py stuff.txt
```

**Input:**

*boop.py*
```python
class boop(object):

    def __init__(self, stuff):
        self.stuff = stuff

    def braaaap(self, green: bool, eggs = 'and ham', answer = 42):
        if green:
            return eggs

        if answer != 42:
            raise Exception  # The answer is always 42.

# Too many references?

def aaa(aaaa, aaaaa = 'aaaaa'):
    aaaaaa = 'aaaaaa'
    return aaaaaa
```

**Output:**

*stuff.txt*
```
Docstrings for boop.py
================================================================================
line 1, boop(stuff):

"""<class description>

Initializer arguments:
    stuff (<type>): <description>

Attributes:
    stuff (<type>): <description>
"""
--------------------------------------------------------------------------------
line 3, boop.__init__(stuff):

"""See class docstring for details."""
--------------------------------------------------------------------------------
line 6, boop.braaaap(green, eggs, answer):

"""<function description>

Arguments:
    green (bool): <description>
    eggs (<type>): <description>
    answer (<type>): <description>

Returns:
    eggs (<type>): <description>

Raises:
    Exception: <description>
"""
================================================================================
line 16, aaa(aaaa, aaaaa):

"""<function description>

Arguments:
    aaaa (<type>): <description>
    aaaaa (<type>): <description>

Returns:
    aaaaaa (<type>): <description>
"""
--------------------------------------------------------------------------------
```

repository: totallyhuman/doc-writer

repo_name: totallyhuman/doc-writer


text:
# JFTex
JFTex is a library for testing JavaFX applications, based on TestFX.

## Features
There are a lot of useful features, like:

__Test without direct input simulation__
>It means that you can run the Test without mouse is moving or focus must have a JFX Node in pane to test. All values are inserted direct from code into the component. After all you can check your background model or the behavior of your pane components.

__Extended Matcher for Assertions__
>There is an extended matcher to run better assertions in test. So you can test on selected items in selectable components, list sizes, list content and special states for chekcable components

__Test Pane__
>Insert your pane and background model into this pane to test manually. So you can do actions on your pane to test and show model changes in a property based live view. Don't forget to call updateModelView(), if pane view model has changed.

## Usage
### Dependencies
You can get the library from maven central repo:

__Maven__
>
<dependency>
>    <groupId>com.github.kleinerhacker</groupId>
>    <artifactId>jftex</artifactId>
>    <version>3.0.0</version>
></dependency>

__Gradle__
>
compile group: 'com.github.kleinerhacker', name: 'jftex', version: '3.0.0'

### Startup with test
To start you must extends your test class from ExtendedApplicationTest to use directly input without input device simulation. To use extended assertion use class ExtendedMatchers in JUnit test functions.

To use the test pane create a class in test folder and create a main method with extension to Apllication of JavaFX framework. Launch the application and put TestPane with your own pane to test and its background model into the scene. Now you can run the test app to run a manually JavaFX UI test.

## Hints
Please note that the Test Pane based on MVVM-FX so you get a test dependency to a weld container implementation.

repository: KleinerHacker/jftex

repo_name: KleinerHacker/jftex


text:
start the dual servers (dapp + mascara)
```
npm run mascara
```

### First time use:

- navigate to: http://localhost:9001
- Create an Account
- go back to http://localhost:9002
- open devTools
- click Sync Tx

### Tests:

```
npm run testMascara
```

Test will run in browser, you will have to have these browsers installed:

- Chrome
- Firefox
- Opera

### Deploy:

Will build and deploy mascara via docker

```
docker-compose build && docker-compose stop && docker-compose up -d && docker-compose logs --tail 200 -f
```

repository: BadgerWallet/badger

repo_name: BadgerWallet/badger


text:
# raspberryEasySurvillance
Easy Survillance Camera Software for Raspberry Pi Zero W with only Open Source Linux Onboard Software.

## Features
* Runs on every Raspberry Pi
* 1 MP resolution
* No hidden backdoors, using only Linux standard software
* No Spyware: Alexa, Siri, ...
* Resistant against **Deauth WIFI attac**
* Run as system deamon
* Motion Detection
* Uploading images to FTP server
* Http: show last snapshot http://raspberrypiCam1.local/snapshot.jpg

## Hardware
* Rsaperry Pi
  * Zero W or
  * Raspberry Pi 4
* Cam Module (without IR filter)
* Power supply
* Case

## Costs
* Raspberry Zero W:    10 Euro
* Raspberry Cam Modul  16 Euro
* Micro SD Card 16GB:   4 Euro
* USB Power Adapeter:   5 Euro
* Case:                12 Euro
* **Total:               47 Euro**

## Prepare
* Get latest Imager: **https://www.raspberrypi.org/software/**
* Flash image: **Raspberry Pi OS lite**
* Configure:
  * there you can change the computer name
  * enable ssh
  * cofigure ssh
  * configure WIFI
* start the raspberry and login via ssh
* upgrade all software
* install git
* Enable rasperyy cam: **sudo raspi-config**
* disable energy saving
  * vi **/etc/network/interfaces**
pre-up iw dev wlan0 set power_save off
post-down iw dev wlan0 set power_save on

## Install
* Clone this GIT repo `git clone https://github.com/mirkoebert/raspberryEasySurvillance.git`
* `cd raspberryEasySurvillance`
* Run `sudo ./install.sh` to install all needed software
* Activate Raspberry Cam running in terminal: `sudo raspi-config`
* Configure this software `./config.sh`
* Check `sudo systemctl status survillancecam.service`

## Manuell Setup
* configure FTP credentials in ~/.netrc
* configure config file
  * set working dir
  * set FTP server name

## Check
* try to get a picutre from the cam: http://your-cam-name/snapshot.jpg

## Troubleshooting
* Ensure that the camera is active
  * https://raspberrypi.stackexchange.com/questions/81753/camera-module-not-getting-detected/116338#116338

## Run
### Run Manually
### Run Automatically
Run as deamon:
* `sudo systemctl start survillancecam.service`

## How it works
* Take a Photo
* Normaize Image
* Compare last two normalized images
* If motion is detected, Upload image to FTP server

## Performance
#### Raspberry Zero W
* Better take a Raspberry Pi 4 or better
* Take a photo and process it:  8.4 sec

### History
* Set time out to 1: 9 sec / image
* Reducing blur: 14 sec / image
* Optimize normalization, reduce colorspace, use faster image format: 23 seconds / image
* Reduce Image size, One complete run takes 23 seconds / image. This mean 2 images per minute.
* Some optimizations: 75 seconds /image
* First try, full image resolution: 90 sec / image

### Details
#### Raspberry Zero W
* take photo: ~~5.8 sec~~ 0.7 sec
* normalize: ~~14.7 sec~~ 5.4 sec
* detect motion: 2.8 sec

## Links
* [Creator Blog](https://programming-2.blogspot.com/2019/12/einfache-bewegungserkennung-auf-dem.html)
* [Achieving high frame rate with a Raspberry Pi camera system](https://chriscarey.com/blog/2017/04/30/achieving-high-frame-rate-with-a-raspberry-pi-camera-system/comment-page-1/)
* [Curl netrc](https://ec.haxx.se/usingcurl/usingcurl-netrc)

repository: mirkoebert/raspberryEasySurvillance

repo_name: mirkoebert/raspberryEasySurvillance


text:
# Gradient matrix generator for Adobe Illustrator

Adobe Illustrator script that generates a matrix of gradient combinations from a selection of colors.

## Installation

Download the `generate-gradient-matrix-illustrator.jsx` file and save it somewhere in your computer.

### Usage

[Click to watch](https://youtu.be/1YJAIgLgRc4) the video below (54s.)

[![Gradient matrix generator Adobe Illustrator Script. Micro tutorial](snapshot.png)](https://youtu.be/1YJAIgLgRc4 "Gradient matrix generator Adobe Illustrator Script. Micro tutorial")

1. Draw as many rectangles as many colors you want to combine.
2. Fill them with the corresponding colors
3. Select the elements you want to combine (at least two)
3. Goto the Illustrator menu option: `File / Script / Other script` and select the file `generate-gradient-matrix-illustrator.jsx`. You can also drag & drop this file to the Illustrator artboard.
5. You'll get the resulting gradients below the selection.
6. Gradient swatches will be added to the `Color Swatches palette`.

You can take a look to the sample `test.ai` file in this repository.

### Configuration and tweaks

- The spacing between the gradient's matrix elements will be the same as the **spacing between the first two elements in the selection.**
- The proportions of the resulting rectangles will be the same proportions of the **first element in the selection.**
- You can get circles instead of squares / rectangles simply **rounding the resulting shapes corners.**

### Info & feedback

This is a fast-and-dirtty adaptation from an [Sketch plugin of my own](https://github.com/carloscabo/gradient-matrix-generator-sketch), don't expect superb-fancy-state-of-the-art coding. If you have any questions / suggestions you can find me at Twitter ([@putuko](https://twitter.com/putuko)). This is an open source plugin so pull request and collaborations are welcome. Greetz.


text:
# Enable-MigrationBatchBasicAuth
This script targets migration batches and places users from these batches in a Azure AD group which allows Basic Auth.

````powershell
<#
.SYNOPSIS
This script targets migration batches and places users from these batches in a Azure AD group which allows Basic Auth.

.DESCRIPTION
This was created to assist with the successful migration of remote clients from Exchange 2013 to Office 365. (See Notes) I must already have allowed the members of the group to use basic auth.

## Enable-MigrationBatchBasicAuth.ps1 [-BasicAuthGroup <string[ObjectID]>] [-SearchString <string[Allows Wildcard]>] [-DifferentialScope <Int[Value]>]

.PARAMETER BasicAuthGroup
The BasicAuthGroup parameter details the ObjectId of the Azure Group which has been setup to allow Basic Authication.

.PARAMETER SearchString
The SearchString parameter allows administrators to be selective as to which migration batchs they would like be included. Default Value selects all migration batches.

.PARAMETER DifferentialScope
The DifferentialScope parameter defines how many objects can be added or removed from the UserGroups in a single operation of the script. The goal of this setting is throttle bulk changes to limit the impact of misconfiguration by an administrator. What value you choose here will be dictated by your userbase and your script schedule. The default value is set to 10 Objects.

.PARAMETER AutomationPSCredential
The DifferentialScope parameter defines how many objects can be added or removed from the UserGroups in a single operation of the script. The goal of this setting is throttle bulk changes to limit the impact of misconfiguration by an administrator. What value you choose here will be dictated by your userbase and your script schedule. The default value is set to 10 Objects.

.EXAMPLE
Enable-MigrationBatchBasicAuth -BasicAuthGroup '7b7c4926-c6d7-4ca8-9bbf-5965751022c2' -SearchString "NYSite1*"

-- ENABLE BASIC AUTH FOR SELECT MIGRATION BATCHES --

In this example the script will collect any user which is included in migration batches "NYSite1*" and add the users to the Group '7b7c4926-c6d7-4ca8-9bbf-5965751022c2'

.EXAMPLE
Enable-MigrationBatchBasicAuth -BasicAuthGroup '7b7c4926-c6d7-4ca8-9bbf-5965751022c2' -DifferentialScope 20

-- ABLE BASIC AUTH FOR ALL MIGRATION BATCHES & INCREASE DIFFERENTIAL SCOPE TO 20 --

In this example the script will collect all migration batchs and adds 20 users to the group '7b7c4926-c6d7-4ca8-9bbf-5965751022c2'

.LINK

Outlook prompts for password when Modern Authentication is enabled - https://support.microsoft.com/en-us/help/3126599/outlook-prompts-for-password-when-modern-authentication-is-enabled

.NOTES
This function requires that you have already created your Azure AD Group and have allowed members of this group to use Basic Authentication via conditional access policies.

Please note, when using Azure Automation with more than one user group the array should be set to JSON for example ['ObjectID','ObjectID']

[AUTHOR]
Joshua Bines, Consultant

Find me on:
* Web:     https://theinformationstore.com.au
* LinkedIn:  https://www.linkedin.com/in/joshua-bines-4451534
* Github:    https://github.com/jbines

[VERSION HISTORY / UPDATES]
0.0.1 20200706 - JBINES - Created the bare bones
1.0.0 20200706 - JBines - [MAJOR RELEASE] Other than that it works like a dream...

[TO DO LIST / PRIORITY]

#>

repository: JBines/Enable-MigrationBatchBasicAuth

repo_name: JBines/Enable-MigrationBatchBasicAuth


text:
Copyright (c) 2015 The University of Edinburgh.

This software was developed as part of the
EC FP7 funded project Adept (Project ID: 610490)
    www.adept-project.eu

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

# Adept Micro Benchmarks - ASSEMBLER

This README file introduces the Assembler Micro Benchmarks.

## Citation & Further Information
If you would like to cite this work, please cite:
Nick Johnson et al., "Adept Deliverable D2.3 - Updated Report on Adept Benchmarks", September 2015.
available at http://www.adept-project.eu/images/Deliverables/Adept%20D2.3.pdf

## Basic Operations

A benchmark to measure the basic operations (add, sub, mult, div) on scalar data types (int, long, float, double).

Each run of the benchmark consists of:

- a warm-up loop
- a timed loop with a `nop` instruction
- an empty timed loop
- loops with the basic operation (written in assembler) of choice, with increasing work per iteration and correspondingly reduced number of iterations (i.e. the number of iteration remains consistent).

The `nop` and empty loops are used to get an understanding of the overheads incurred by the loop. Similary, increasing the number of operations per loop iterations while reducing the number of iterations gives an idea of how work inside a loop impacts performance and power.

The user can choose if the data used as part of the operations is volatile (i.e. read from memory at each access). The options are no volatile variables (default), ONEVOL where 1 of the variable is declared volatile, or ALLVOL where all the variables are volatile.

repository: EPCCed/adept-micro-assembler

repo_name: EPCCed/adept-micro-assembler


text:
# V1.5 - Community Enhancement Megapack

Hey everyone. Big release today, but not for the reasons we expected...

We'd intended to build out a basic file menu to allow us to add a few settings, but so many of you in the community started building enhancements we're instead pushing a release with a whole bunch of amazing stuff we'd never thought of!

## Big New Features in this release

### Run Contexts

Instead of running the entire query window, you can now selectively run whatever you wish:
- Run All - run the whole editor
- Run Current - If you have multiple queries (separated with `;`), you can run whichever query you're currently selecting (we'll highlight the query to let yo uknow)
- Run Selection - Select some text and then you can just run whatever text you have highlighted.

![SQL Run contexts](https://user-images.githubusercontent.com/279769/84578583-3423a780-ad8c-11ea-8fcc-6b6d6c740bc2.gif)

### Query Parameters

Parameterize your SQL query with either `:variable` or `$1` and when you run the query Beekeeper will prompt you to enter values. Now you can re-use the same query easily without having to open a whole new tab.

![SQL Parameters](https://camo.githubusercontent.com/6582a2b09ef9b567bb5470a76276daee5aa36765/68747470733a2f2f6d656469612e67697068792e636f6d2f6d656469612f5176644c45476b4c7a35706f5272547a6e592f67697068792e676966)

### Connection Label Colors

Label your saved connections with a color. Now you can easily tell `production` from `dev` connections.

![Color Picker](https://user-images.githubusercontent.com/279769/84578500-7a2c3b80-ad8b-11ea-83ee-659a9fd999a3.gif)

### Smaller Fixes and Enhancements
- Refresh the database list with a new `refresh` button
- Beekeeper Studio now works on Debian 10
- Postgres versions before 8.3 are now supported
- Redshift errors are fixed
- Close tabs with a middle mouse button click
- Electron Updated to 8.2.5
- Deb package now adds the Beekeeper Studio repo if downloaded directly

Most of these enhancements came from you, the community.

## Merged Pull Requests

#183 from beekeeper-studio/deb-postinstall
#196 from beekeeper-studio/launcher-linux
#193 from JamesDBartlett/master
#191 from beekeeper-studio/dependabot/npm_and_yarn/websocket-extensions-0.1.4
#131 from mlebrun/connection-labels
#181 from beekeeper-studio/highlight-fixes-and-docs
#168 from aligoren/feature/refresh-button-for-databases
#165 from MasterOdin/patch-3
#99 from hillmanov/master
#171 from beekeeper-studio/query-highlighting
#167 from MasterOdin/master
#161 from vuongggggg/feature/add-run-buttons
#166 from beekeeper-studio/component-library
#164 from strotgen/feature/close-tab-middle-button
#156 from beekeeper-studio/connection-removal

repository: ozeas/beekeeper-studio

repo_name: ozeas/beekeeper-studio


text:
# lunchbuddies
An app for creating semi-random pairings
deployed app link: https://lunchbuddies.herokuapp.com/

## Problem Description
In large companies there often will be people or groups of people that do not interact regularly.  It can be a challenging problem to find ways to identify where connections need to be made.

## Our Solution
  * We our creating an application that will generate semi-randomized pairings. At it's core, this application is being designed to create partner pairings to facilitate enhanced involvement between team members, potentially at different levels within an organization.

## Benefits of this Solution
  * Provide a more inclusive work environment.
  * Foster empathy and understanding amongst and between different echelons of a company.
  * Help prevent a 'clique' mentality from forming.
  * Encourage innovation by bringing together people with varying ideas and viewpoints.
  * Help foster transparency and respect.

## Technologies Used

Lunch Buddies uses jQuery(utilizing MVC file structure), HTML and CSS(SMACSS file structure) and Handlebars (HTML templating) to create a single-page application on the client side, along with a reponsive, mobile-first UI.  We are using an API we created with Node.js to interact with a PostgresSQL database on our backend, deployed via Heroku, and planned/implemented over a weeklong dash.

## James C. Woodson

I grew up in West Seattle and have lived most of my life in the greater Seattle area. With a Bachelor's of Science in Biochemistry from the University of Washington, most of my professional experience has been in research. Over time I found that the favorite part of my work was scripting data analyses in R and other programming-related tasks, so making the transition into the tech industry seemed like a sound move to make.

## Don Pham

I graduated from the UW with a degree in Comparative History of Ideas and a focus in media theory.  I've spent the past decade working in ethnic media, where I managed to shoot and edit over 200 news clips in a language he does not understand.  So I know how to adapt.  I am grateful for WTIA’s Apprenti program for taking a chance on someone from a non-traditional background.

## Roscoe B. Bass III

I've done much with my 35 years of life so far, including but not limited to: a dance instructor, a Navy Air Traffic Controller, a banker for a number of banks, a pest control technician, and most recently a boxing coach and instructor.  Through my vast experiences, I've learned that I attract to occupations that include a nice mix of math, problem solving, and helping others.  Which is why I'm now pursuing a career in software development.  I'm thankful to Apprenti for giving me a chance to walk this path, a chance I doubt I would've gotten without them.

repository: RandomRobins/lunchbuddies

branch_name: refs/heads/development

repo_name: RandomRobins/lunchbuddies


text:
# react-scripts-inversify

This is a fork of `react-scripts`. This fork changes the `tsconfig.json` and `webpack.config.js` to retain metadata that can be used at runtime (for dependency injection for example).

To use these scripts, add `--scripts-version react-scripts-inversify` when creating a new app.

For example:

```sh
npx create-react-app my-app --scripts-version react-scripts-inversify
```

alternatively

```sh
npx create-react-app-inversify my-app
```

## Changes:

### tsconfig.json
 * `experimentalDecorators`: true
 * `emitDecoratorMetadata`: true

### webpack.config.js
 * uses `ts-loader` rather than `babel` to compile typescript. Decorator metadata no longer removed.

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

- [Getting Started](https://facebook.github.io/create-react-app/docs/getting-started) – How to create a new app.
- [User Guide](https://facebook.github.io/create-react-app/) – How to develop apps bootstrapped with Create React App.

repository: Roaders/inversify-create-react-app

repo_name: Roaders/inversify-create-react-app


text:
# websocket

[![Latest Version on Packagist][ico-version]][link-packagist]
[![Software License][ico-license]](LICENSE.md)

PHP websocket server and client. Supports secure sockets.

## Install

Via Composer

``` bash
$ composer require vakata/websocket
```

## Server usage

``` php
// this handler will forward each message to all clients (except the sender)
$server = new \vakata\websocket\Server('ws://<IP_ADDRESS>:8080');
$server->onMessage(function ($sender, $message, $server) {
    foreach ($server->getClients() as $client) {
        if ($client !== $sender) {
            $client->send($message);
        }
    }
});
$server->run();
```

## Client usage

``` php
// this handler will echo each message to standard output
$client = new \vakata\websocket\Client('ws://<IP_ADDRESS>:8080');
$client->onMessage(function ($message, $client) {
    echo $message . "\r\n";
});
$client->connect();
```

## Usage in HTML

``` js
var sock = new WebSocket('ws://<IP_ADDRESS>:8080/');
sock.send("TEST");
```

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

## Security

If you discover any security related issues, please email<EMAIL_ADDRESS>instead of using the issue tracker.

## Credits

- [vakata][link-author]

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

[ico-version]: https://img.shields.io/packagist/v/vakata/websocket.svg?style=flat-square
[ico-license]: https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square

[link-packagist]: https://packagist.org/packages/vakata/websocket
[link-downloads]: https://packagist.org/packages/vakata/websocket
[link-author]: https://github.com/vakata

repository: vakata/websocket

gha_language: PHP

repo_name: vakata/websocket


text:
# tetris
Tetris game written in JAVA and JAVAFX

# Tetris-project
Project of Tetris game in JAVA

List of classes with short description

TScore            - class that calculates and stores points of actual game
THighScore        - class storing best 10 scores and best score of every individual player using lists and serialization
TBoard            - class with logical representation of blocks that already landed on the board and methods for clearing lines
TBlock            - class that is logical representation of block
TBlocksShapes     - class with representation of  I O T J L Z S tetrominoes, and their rotations
TBlockRandomizer  - class with an algorithm TGM1 which is choosing next block
TGameController   - connects all parts of the game and controls behavior of the game
TLayoutParts      - class that generate JAVAFX objects for others

List of tetrominoes
1 deep blue - I tetromino
2 red       - O tetromino
3 yellow    - T tetromino
4 green     - J tetromino
5 purple    - L tetromino
6 orange    - Z tetromino
7 blue      - S tetromino


text:
# PHPMongoQuery

Mongo queries in PHP

PHPMongoQuery implements MongoDB queries in PHP, allowing developers to query a 'document' (an array containing data) against a Mongo query object, returning a boolean value for pass or fail.  Additionally a set of documents can be queried to filter them, as queries are used in MongoDB.

This code is used at Akkroo to allow the construction of advanced form logic queries in the form field definition.

## Usage

```php
<?php

use Akkroo\PHPMongoQuery;

$query = array('a' => 'foo', 'b' => array('$ne' => 'bar'));
$document = array(
			'id' => 1,
			'a' => 'foo',
			'b' => 'barr'
		);
var_dump(PHPMongoQuery::executeQuery($query, $document));
```

This will output

```
bool(true)
```

## Methods

### find($query, $documents, $options)

Perform a query on a set of documents to filter out only those which pass the query

### executeQuery($query, $documents, $options)

Execute a query on a single document, returning a boolean value for pass or fail

### appendFieldSpecifier($query, $append)

Append a field specifier to any field queries.  For example, your query may have been written as follows:

	$query = array('a' => 'foo');

However, the actual document structure is

	$document = array('a' => array('value' => 'foo'), 'b' => array('value' => 'bar'));

So you need to append the 'value' specifier to the query field specifiers for the query to work.  For example:

	$newQuery = PHPMongoQuery::appendFieldSpecifier($query, 'value');
	// $newQuery is array('a.value' => 'foo');

### getDependentFields($query)

Parse a query to find all the fields it depends on.  This is useful for listening to when those values change, so the query is only repeated when the result could have changed.  For example:

	$query = array('a' => 'foo');
	$dependentFields = PHPMongoQuery::getDependentFields($query);
	// $dependentFields is array('a');

repository: Akkroo/PHPMongoQuery

repo_name: Akkroo/PHPMongoQuery


text:
# sengen: Python Sensor Data Generator

## Welcome

sengen is a fork of the Mandrova open-source python library for scientific data generation.  The code was forked so it could be uploaded to PyPi.

It supports stationary, non-stationary, and even user-specified generation schemes.

## Simple Start

Importing Sensor Data Generator

```python
from sengen.data_generator import SensorDataGenerator as sdg
```

Decleration of Important Variables For Generation

```python
seed = 20171221
sample_size = 1000
dg = sdg()
```

Generation Options

```python
dg.generation_input.add_option(sensor_names="Hello", distribution="normal", mu=0, sigma=1)
dg.generation_input.add_option(sensor_names="World", eq="x",
                               initial={"x":0}, step={"x":1})
```

Generate

```python
dg.generate(sample_size=sample_size, seed=seed)
```

Save Data Table

1. As .csv
```python
dg.save_as_csv(file_name="hello_world")
```

2. As .xlsx
```python
dg.save_as_excel(file_name="hello", sheet_name="world")
```

## Tutorials

- [Chapter1: Data Generation](tutorials/chapter1_data_generation.ipynb)
- [Chapter2: Data Modification](tutorials/chapter2_data_modification.ipynb)
- [Chapter3: Stationary Examples](tutorials/chapter3_stationary_examples.ipynb)
- [Chapter4: Non-Stationary Examples](tutorials/chapter4_non_stationary_examples.ipynb)
- [Chapter5: Complex Generation Example](tutorials/chapter5_complex_generation_example.ipynb)
- [Appendix A: Playing With Lorenz Attractor](tutorials/appendix_a_playing_with_lorenz_attractor.ipynb)

## Contributor
- Jong Duk Shinn

### Special Thanks to:
Development:
- Andre Yoon
- Sangwoo Shim
- Yongsub Lim
- Ki Hyun Kim
- Byungchan Kim<EMAIL_ADDRESS>
Logo Design:
- Yujin Han

repository: MrPowers/sengen

repo_name: MrPowers/sengen