text:
# Fall 2017 Source Syllabus

## Description:
Source is a **backend** web development program. You will learn to communicate with the internet, write the business logic that drives web applications, and manipulate the servers that will ultimately deploy and deliver them. The course will be taught in JavaScript and NodeJS

## Who This Program is For:
Source is targeted toward people with a preference for the **logic** of programming, be it a **first-year in CS1110** who is looking to translate their knowledge into functional services, a **Wireframe grad** who wants to learn server-side web development, or an **entrepreneur** who wants to improve their tech savviness. If you’re more interested in the inner-workings of a web application rather than the presentation, this is the class for you.

**No programming experience** is required, as all the code will be explained line-by-line, but understand that an unwillingness to learn coding outside of class will completely limit your ability to build off the course material in your recreational coding or career.

## Class Format:
We will meet twice a week:
* Lecture: Tues 6:45-8:15pm in Launchpad
  * Introduce concepts and examples
* Workshop: Sun 11am-12:15pm in 17
  * Reinforce skills and build projects

## Community:
Participants will be integrated in three aspects of the HC community
1. Source participants:
  * 1 on 1’s
  * Study sessions
  * Socials
2. Other program participants:
  * Project collaborations
  * Special interest groups (Tech, photo, sustainability, etc)
3. HackCville
  * Exposure to leadership
  * Community dinners

## Expectations
* Attend all lectures and workshops
  * Absences beyond 5 will result in failure to complete the program
* Attend a community event every week for the first 3 weeks
* Grab coffee with another Source student
* Project:
  * Due at the end of the semester
  * Consumes at least 1 web API
  * Source project may be submitted to another class, but a class project may not be your Source project

## Class Schedule:
Here is an overview of the topics that will be covered, and the general order in which they will be presented.
1. **Intro to Bash and Git**
  * Description: Anyone working in tech can benefit from knowing a little bash and git. Rather than copying strange hieroglyphics from a tutorial, find out how the command line works and why you should incorporate it into your workflow.
  * Objectives: Introduce common command line functions like cd, ls, mkdir, git, and their relevance in software development and project management.
  * Workshop: Directory navigation in bash. Git workflow practice.
2. **JavaScript: Part 1**
  * Description: JavaScript will be our main language this semester, and it is important for you to be comfortable with it.
  * Objectives: Familiarize yourself with JavaScript syntax, and learn the basics features like string manipulation, arithmetic, and arrays.
  * Workshop: Practice JS on FreeCodeCamp.
3. **JavaScript: Part 2**
  * Description: We will continue to practice JS this week while covering intermediate topics such as functions, classes, and JSON.
  * Objectives: Become familiar with object oriented programming in JS.
  * Workshop: Practice JS on Codecademy.
4. **Node.js: More than Just a Frontend Language**
  * Description: Node.js has revolutionized web development by allowing Javascript to be run on servers, just like Python or Java. It’s fast, and has a huge community of developers.
  * Objectives: Use Node.js and Express.js to write a web server.
  * Workshop: Work on website examples using Express.
5. **Understanding Async**
  * Description: Most HTTP requests that we make with JavaScript will be asynchronous, which surprises beginners. We will see how to make use of promises and callback functions to handle async methods.
  * Objectives: Explain the meaning of async functions, and how to handle them using JS features.
  * Workshop: Write a web scraper using JavaScript and Node.
6. **How Computers Talk to Each Other: HTTP and REST APIs**
  * Description: Our web applications often receive communications from other computers on the internet, which is handled by the backend code. Thankfully, there are frameworks that make it easy to handle those requests.
  * Objectives: Introduce the basics of HTTP and data formats
  * Workshop: Write a simple REST API that provides some simple dataset.
7. **Web Sockets: Interactive Communication**
  * Description: You've set up a web server, but you want communication to be a two-way street. How can clients send information to the server on top of receiving data from the server? The answer--web sockets!
  * Objectives: Become familiar with web sockets and Socket.io.
  * Workshop: Write a chat application using Node.js, Socket.io, and Javascript.
8. **Self-Hosting Servers: Leveraging Your Router and Local Network**
  * Description: You’ve built a simple web server, and you want to show friends, family, and employers. You want to host it online, but your $7 monthly allowance is already being spent on Netflix.
  * Objectives: In this class you will learn how to hack the internet service and router that you already pay for, and use it to host the Node.js web server from the Raspberry Pi.
  * Workshop: Practice making HTTP requests via NodeJS.
9. **No Servers? No Problem: Moving to the Cloud**
  * Description: Expecting hundreds of visitors but don’t own a mansion? Learn how even the absence of hardware can be solved with cloud computing. We will move our self-hosted website to the cloud, freeing it from our own hardware’s limitations. Useful for people who are scaling up their project at minimal cost.
  * Objectives: Understand the benefits of cloud computing, setting up an AWS account, and spinning up an EC2 micro instance.
  * Workshop: Move the web server to Amazon Web Services, and introduce the benefits of cloud computing.
10. **ES6: JavaScript for the Future (Possible Elective?)**
  * Description: While JavaScript became more popular for web developers, it lacked many features compared to other programming languages. ES6 is the latest version of JavaScript, and incorporates features that make backend work much easier.
  * Objectives: Cover the most useful features of ES6, including Classes, arrow functions, and destructuring.
  * Workshop: Practice using ES6 and set up Babel for transpiling to vanilla JS.
11. **Elective Topic: Electron/Databases/Web Technologies**
  * Workshop: Work on project.
12. **Crossover Topic: Data Science/Frontend**
  * Workshop: Work on project
13. **Siri, Alexa, and Cortana Oh My! : Developing for the Internet of Things**
  * Description: Voice is quickly becoming essential to the way we interact with the internet, and it’s easy to create apps for voice assistants like Amazon’s Alexa.
  * Objectives: Combine our knowledge of JavaScript and Node to write a simple Alexa skill.

repository: xiexieeric/source

repo_name: xiexieeric/source


text:
# read-csv

## run the project
1. make sure you have python3 and pip install in your machine
2. pip install -r requirements.txt / pip install requirements.txt
3. replace the [data directory](./src/data) with your data
4. run the [readcsv.py script](./src/readcsv.py)

license: MIT

branch_name: refs/heads/main

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive


text:
bleed
=====

Node.js module to consume memory in a configurable and predictable way.

# Usage

```
$ npm install bleed
```

```js
var bleed = require('bleed');

bleed(options, callback);
```

`options.bytes` {Number} The number of bytes to allocate.
`options.time` {Number} The amount of time, in milliseconds, to take to allocate the memory.
`options.increments` {Number} The number of allocations to perform. The timespan will be divided into even increments and one allocation will occur per increment.
`options.debug` {Boolean} Whether or not to print debug messages to console when running.
`callback` {Function} Called when done. Includes the buffers that were allocated.

# Examples

```js
// Bleed 1 gigabyte of memory over 60 seconds. One allocation per second.
var options = {
  bytes = bleed.ONE_GIGABYTE;
  time = 60000;
  increments = 60;
};

bleed(options, function(err, buffers) { console.log('DONE!') });
```

```js
// Bleed 50 megabytes of memory.
var options = {
  bytes = bleed.ONE_MEGABYTE * 50;
};

bleed(options, function(err, buffers) { console.log('DONE!') });
```

```js
// Bleed 2 gigabytes of data over 30 seconds. One allocation very 2 seconds.
var options = {
  bytes = 2 * bleed.ONE_GIGABYTE;
  time = 30000;
  increments = 15;
};

bleed(options, function(err, buffers) { console.log('DONE!') });

```

repository: InconceivableDuck/bleed

branch_name: refs/heads/master

repo_name: InconceivableDuck/bleed


text:
# wsproxy
wsproxy is a tunnel client and server base on websocket.
It is designed for the situation that you use a network behead a firewall who only let http request go.

wsproxy client connects to wsproxy server with websocket protocol which firewall will treat it as http. wsproxy server can connect to any tcp server whose address is specified by client.

# Use case

## Connect to a ssh server

To connect to a ssh server listen on example.com:22, run server on a computer A outside the firewall by command:
> ./server -l "<IP_ADDRESS>:1234"

And run client in a firewall protected network with command:
> ./client -s "ws://A:1234" -l ":5678" -r "example.com:22"

Then ssh to the localhost:5678 to connect to the remote ssh server. The data path is
> ssh-client -(tcp)->
> wsproxy-client -(websocket)->
> wsproxy-server -(tcp)->
> ssh-server

repository: kkstun/wsproxy

repo_name: kkstun/wsproxy


text:
# Build Instructions

The goal of these instructions is to build a single image that contains all the tools used by openlane.
This is done through two stages.

1. Building
2. Merging

### Note

The repo already provides a snapshot of the tarballs which are generated by going through step 1, so you can jump to 2 if you wish to save time building the tools.

## Building

The following make target iteratively builds each tool in a separate docker image (i.e. one docker image per tool). Then we export the binaries generated by each tool's image to tarballs in `tar` directory.

```bash
make build-all
```

## Merging

Finally, we merge all the tools in a single docker image.

```bash
make merge
```

## Additional information

### Building and exporting a specific tool

You can choose to build and export a specific tool by running:

```bash
make build-<tool>
```

The following are the available tools:

```bash
klayout replace opendp route cugr drcu opensta yosys antmicro_yosys magic openroad_app padring netgen vlogtoverilog openphysyn cvc
```

### Rebuilding
Following that, go through steps 1 and 2 to generate and update docker image.

```bash
make build-all DOCKER_BUILD_OPTS=--no-cache

make merge
```

This should you remove the existing tarballs. Then, build and export specific tool(s).

repository: mattvenn/openlane

repo_name: mattvenn/openlane


text:
*Forked version for Previz*

- merged https://github.com/joaopereirawd/animatedModal.js/pull/18

# animatedModal.js

animatedModal.js is a jQuery plugin to create a fullscreen modal with CSS3 transitions. You can use the transitions from animate.css or create your own transitions.

Documentation and demos


text:
# Finale 2.1 Draft

## Bug fixes

- Fixed no vehicle damage bug.
- Fixed erratic knockback.
- Fixed sprinting with no hunger bug.
- Fixed sprint breaking intermittently in 1.18.

*Below changes are experimental; some have already been written and being tested on Helios.*

## Allies

Bow & Arrows have been severely underpowered and in the context of larger-scale fights generally more of a liability than a viable weapon. This is partly because in these bigger fights, you're just as likely to hit your teammates as you are to hit the enemy.

By marking your friends as allies:
- Their name becomes blue.
- They become visible while invisible.
- Projectile friendly-fire is disabled; projectiles will go through your allies.
- Their warp fruit animation particles become blue.

Melee friendly-fire is still enabled.

Commands:
- /ally add <player-name> - Mark another player as an ally.
- /ally remove <player-name> - Remove another player as an ally.
- /ally list - List your allies.

```
ally:
  enabled: true
  seeInvis: true # should you be able to see invisible allies?
  animateLink: # settings for animating adding/removing ally
    enabled: true
    maxDistance: 20
  storage:
    file: ally.sqlite
```

## Enhanced Tipped Arrows

Finale now has options to configure the duration of all tipped arrows.

```
tippedArrows:
    nightvision:
        name: Arrow of Night Vision
        type: NIGHT_VISION
        durations:
            normal: 440
            extended: 1200
            amplified: 220
        color:
            r: 3
            g: 32
            b: 126
    regen:
        name: Arrow of Regeneration
        type: REGEN
        durations: # duration in ticks (20 ticks = 1 second)
            normal: 100
            extended: 220
            amplified: 40
        color:
            r: 188
            g: 102
            b: 146
```

Another issue of the arrow is that they've always been pretty hard to hit, particularly when there is a large ping disparity between players, so most arrows don't do much damage and don't land on target.

After travelling [x] metres, tipped arrows will have a tiny area of effect of [y] metres.

```
enhancedArrows:
    enabled: true
    minDistance: 10 # how far should arrow travel for arrows to become area of effect?
    radius: 2
    damage: 1
    allyDamageReduction: 1 # how much damage to reduce against allied players? 1 = negate all damage, 0 = full friendly fire
    allyCollide: false # should arrows collide with allies?
```

## Warp Fruit

This isn't a silver bullet against trapping but it helps.

Warp fruit tracks your previous locations going back [x] seconds in the past. When you eat a chorus fruit, you teleport back to where you were [x] seconds ago. This ability then goes on cooldown for [y] seconds.

While you are eating the warp fruit, there is an animation and particles marking where you are and where you're going to teleport to. You also glow while eating (spectral).

During this animation, the particles will show as green to yourself, blue to allies, and purple to everyone else.

```
# the warp fruit will roll back to 7 seconds ago
warpFruit: # logSize * logInterval = how far back in time you go
    logSize: 35 # log queue size
    logInterval: 200ms # in milliseconds
    cooldown: 10s
    maxDistance: 100 # max warp distance
    spectralWhileChanneling: true
```

## New Offhands

Food and knockback 2 swords have been offhand favourites for a long time now; it's time we bring Tridents and Shields into the fold.

### Shield

In our pvp system, shields have had almost exclusively an ornamental value. The following changes will give it defensive value within the context of our system.

After activating block with your shield, you will boost forward in the direction you are looking and proportionally push back enemies in your way. This ability goes on cooldown for [x] seconds.

Another option is a passive resistance effect while a shield is equipped.

```
shield:
  bash:
    enabled: true
    activationResistance:
      enabled: true
      amplifier: 0
      duration: 200
  passive:
    enabled: false
    amplifier: 0
```

### Trident

In the vanilla game, if you throw your trident from your offhand and pick it back up (from loyalty or off the ground), it won't return to your offhand but simply be added back to your main inventory. An offhand that you keep having to put back in your offhand isn't a great offhand. So now, if you pick up your trident - of which you threw from your offhand - and your offhand slot is available, then it will return to your offhand. If your offhand slot is unavailable, then it goes to your main inventory like normal.

Riptide will go on cooldown for [x] seconds after use.

Tridents, in general, will go on cooldown for [y] seconds after use.

```
trident:
    returnToOffhand: true # if you throw the trident with your offhand, should it return to your offhand?
    generalCooldown: 10s
    riptideCooldown: 60s
```

Tridents have a valid damage modifier:
```
damageModifiers:
    ...
    TRIDENT:
        multiplier: 1.0
        mode: DIRECT
    ...
```

## Crossbows

Fireworks also have a valid damage modifier now, so damage from fireworks towards players can be adjusted.

```
damageModifiers:
    ...
    FIREWORK:
        multiplier: 1.0
        mode: DIRECT
    ...
```

Fireworks can damage reinforcements and bastion fields.
Firing fireworks from crossbows will go on cooldown for [x] seconds after use.

```
crossbow:
  reinforcementDamage: 5
  bastionDamage: 5
  cooldown: 4000ms
```

## Block Place Combat Restrictions

While in combat, the following restrictions can be placed:
- A blacklist of blocks that can't be placed.
- A whitelist of blocks that can be placed.
- A list of blocks that have a cooldown on placement.

```
blockPlacementRestrictions:
  enabled: true
  mode: BLACKLIST # BLACKLIST, WHITELIST
  blacklist:
    - COBWEB
    - OBSIDIAN
  whitelist:
    - WATER_BUCKET
    - COBBLESTONE
  cooldowns:
    cobweb:
      type: COBWEB
      cooldown: 5s
    obsidian:
      type: OBSIDIAN
      cooldown: 1s
```

repository: jaymsDooku/Finale

path: /notes/Finale 2.1.md

filename: Finale 2.1.md

repo_name: jaymsDooku/Finale


text:
Answer the following questions for each of the data structures you implemented as part of this project.

Queue
What is the runtime complexity of enqueue?

What is the runtime complexity of dequeue?

What is the runtime complexity of len?

Binary Search Tree
What is the runtime complexity of insert?

What is the runtime complexity of contains?

What is the runtime complexity of get_max?

Heap
What is the runtime complexity of _bubble_up?

What is the runtime complexity of _sift_down?

What is the runtime complexity of insert?

What is the runtime complexity of delete?

What is the runtime complexity of get_max?

Doubly Linked List
What is the runtime complexity of ListNode.insert_after?

What is the runtime complexity of ListNode.insert_before?

What is the runtime complexity of ListNode.delete?

What is the runtime complexity of DoublyLinkedList.add_to_head?

What is the runtime complexity of DoublyLinkedList.remove_from_head?

What is the runtime complexity of DoublyLinkedList.add_to_tail?

What is the runtime complexity of DoublyLinkedList.remove_from_tail?

What is the runtime complexity of DoublyLinkedList.move_to_front?

What is the runtime complexity of DoublyLinkedList.move_to_end?

What is the runtime complexity of DoublyLinkedList.delete?

a. Compare the runtime of the doubly linked list's delete method with the worst-case runtime of the JS Array.splice method. Which method generally performs better?


text:
---
layout: post
title: ld.lld and linker files
---

LLVM's linker was a real pain...

# LLVM linker (ld.lld-5.0)

To get my STM32 to run I have to tell the linker where to store the executable data.
This is usually done with a linker file. But unfortunately `ld.lld` doesn't support the same gcc-linker syntax.

## Memory definition

We first start with the memory definition file

`STM32-linker/STM32F3/STM32F303VC.ld`
```
MEMORY{
	RAM    (xrw)  : ORIGIN = 0x20000000, LENGTH = 40K
	FLASH  (rx)   : ORIGIN = 0x08000000, LENGTH = 256K
	CCMRAM (xrw)  : ORIGIN = 0x10000000, LENGTH = 8K
}
```

The STM32F303VC6 which is used in the STM32F3Discovery board is defined by this (mem) linker file.
We see that this Chip has a `RAM` region in `0x20000000` which is 40KB long and used for saving variables and the stack.
Also it has a `FLASH` region for the program code at the adress `0x0800000` which is 256KB long.
And we just ignore the `CCMRAM`.

## (simple) linker file

Now we want to define a simple linker file. We tell meson in the `meson.build` file to use the memory layout file and append the simple linker file together.
So we have a uC agnostic linker file and for every uC an independent memory layout file.

```
OUTPUT_FORMAT ("elf32-littlearm", "elf32-bigarm", "elf32-littlearm")

/* define entry point */
ENTRY(Reset_Handler)
```

first we have some configuration shenanigans. Without any further explanation.
Then starts the black magic

```
/* calculate the Last RAM address*/
 _estack = ORIGIN(RAM) + LENGTH(RAM) - 1;
```
we first define a variable with the the start-address of the stack pointer.
It will be on the top of the RAM memory.

```
SECTIONS
{
	/*--------------------------------------------------------------------------*/
  /* interrupt vector goes at the beginning of FLASH */
	.isr_vector : {
			. = ALIGN(4);					/* align */
			_sisr_vector = .;     /* define start symbol */
			KEEP(*(.isr_vector))  /* Interrupt vectors */
			. = ALIGN(4);					/* align */
			_eisr_vector = .;			/* define end symbol */
  } > FLASH
```

then we define the first memory entry in the FLASH memory. It's the interrupt vector table.

### define a section
this syntax defines a block with the name `.<region>` which going to be saved in the `FLASH` memory
```
 .<region> : {
   ...
 } > FLASH
```

The command `KEEP(*(.isr_vector))` will copy the section defined in the startupfile with the name `.isr_vector` in the surrounding `<region>`.

Sadly I used the same name for region and the section defined in the startupfile.

next we copy the program code and constant values to the `FLASH` memory
```
  /*--------------------------------------------------------------------------*/
  /* program data goes into FLASH */
  .text : {
      . = ALIGN(4);					/* align */
      _stext = .;           /* define start symbol */
      *(.text)						  /* insert program code .text */
      *(.text*)             /* .text* sections */

      *(.glue_7)            /* glue arm to thumb code */
      *(.glue_7t)           /* glue thumb to arm code */
      *(.eh_frame)

      . = ALIGN(4);				  /* align */
      _etext = .;           /* define end symbol */
  } > FLASH
  /*--------------------------------------------------------------------------*/
  /* constant data goes into FLASH */
  .rodata : {
     *(.rodata)            /* .rodata sections (constants, strings, etc.) */
     *(.rodata*)           /* .rodata* sections (constants, strings, etc.) */
     . = ALIGN(4);         /* align */
      _erodata = .;
  } > FLASH
```

As you can read in the comments : `*(.text)` is the program code and the glue sections are some special arm / thumb magic.

then follows some more arm magic
```
/* ARM stack unwinding section (GDB uses this) */
.ARM.extab : {
     __extab_start__ = .;/* define start symbol */
     *(.ARM.extab* .gnu.linkonce.armextab.*)
     __extab_end__ = .;  /* define end symbol */
} > FLASH

.ARM : {
     __exidx_start__ = .;/* define start symbol */
     *(.ARM.exidx* .gnu.linkonce.armexidx.*)
     __exidx_end__ = .;  /* define end symbol */
} > FLASH
```

### Initialized globals
Then we want to save the global variables which are initialized with a defined value.
We have to link the variable addresses in the RAM memory, but we have to save the initial values in the `FLASH` memory.
In gcc you would do this like this:

```
 .<region> : {
   ...
 } >RAM AT >FLASH

```
But this failes in llvm's linker.

I had some time to figure this out...

-   define all the `FLASH` regions
-   set the current address locator to the RAM address space `. = ORIGIN(RAM);`

And then define the RAM region which values are stored in FLASH memory

```
. = ORIGIN(RAM);

.<region> : AT(<Flash-location>) {
    ...
 } > RAM

 <marker> = LOADADRESS(.<region>)
```

Any other way will fail!
So in the end I defined it that way:
```
. = ORIGIN(RAM);

.data : AT(__exidx_end__) {
    _sdata = .;            /* create a global symbol at data start */
    *(.data)              /* .data sections */
    *(.data*)             /* .data* sections */

    . = ALIGN(4);         /* align */
    _edata = .;           /* define a global symbol at data end */
 } > RAM

 _sidata = LOADADDR(.data); /* get the start address of the .data section */
```

As you might expect `*(.data)` are the values. We store them appending to the `__exidx_end__` address in `FLASH`.
The linker will reserve the same space in `RAM`. Also we define a location variable `_sidata` and copy the address of the `.data` section to it

We will need to copy the values from `FLASH` to `RAM` **by Hand** in the startup file.

and then follows the so called `.bss` section with uninitialized variables and a special arm attribute `.ARM.attributes 0 : { *(.ARM.attributes) }`

### conclusion
After hours of trial and error I finally got a minimalistic linker file to work with my microcontrollers.
`ld.lld` might not be in a very mature state at the moment.
But maybe this will be better with LLVM-6.0


text:
+++
author = "Peter Souter"
categories = ["personal", "fitness", "data", "kettlebells"]
date = 2016-06-16T22:27:25Z
description = ""
draft = false
coverImage = "/images/2016/10/Screenshot-2016-06-16-23.11.34-1.png"
slug = "90-day-fitness-challenge"
tags = ["personal", "fitness", "data", "kettlebells"]
title = "90 Day Fitness Challenge - Week 1 - First check-in"

+++

So after writing about something a little more personal, I'm going to continue talking about data driven fitness!

So, after finding out my actual statistics from the DEXA scan and not making the progress I want, I tried to go back to the drawing board.

Look at the data, look at the target, set realistic goals.

SO I'm going to stick to a routine that's:

* Easy to do in a crowded gym - It's hitting summer now and peak times at the gym equipment is pretty sparse. Something that avoided the super busy squat rack and bench would be nice.
* Something I can do at home in a pinch - Sometimes I'm tired, sometimes I'm working, sometimes I'm traveling the next day. Hell, sometimes it's raining and I don't want to leave the house!
* Something that is both a cardio and weight workout. Cardio is great, but it's an easy way to accidentally lose muscle if you're not careful. The same way lifting weights is great, but it's hard to use it to burn calories. A super intense deadlifting session is short spurts of effort, and it's estimated to only burn around 150-200 calories.
* Something super simple - I like the term dedicated but lazy, it's basically how I do most of my work. I want something that's easy to setup, but I can keep at without having to tweak to much.
* Easy to track progress - Something where I can see a number go up or down. With any deadline you need acceptance criteria. Weight and body fat is one thing, but that moves slowly and is hard to accurately measure. So being able to see the progress I'm making in the

So I went to the data. Looking back over my weight loss for the last two years, the most I lost consistently was when I was doing a kettlebell routine:

![](/images/2016/10/Screenshot-2016-06-16-23.11.34.png)

4.0kg weight lost over 3 months, not too shabby!

That was the [10000 Swings workout](https://www.t-nation.com/workouts/10000-swing-kettlebell-workout) (Warning: There's a lot of male nipples on display, maybe a little NSFW depending on where you work!).

At the time I wasn't actually fit enough to do 20kg, so I was doing 16kg. Now I feel I could do 20kg (the guide actually says 24kg, but I only have a 20kg at home, so I'm going to play it safe!).

So to start with I did a little warmup to get a vague idea of where I'm starting. Since the scan was May 31st, I wanted to find out my Day 0 time. I went with doing 200 swings a few times to feel out how hard it would be, and what kind of times I could expect before I threw myself fully into the 500 a day.

### 200 Swings Total Time

```
16:10 min for 200 swings - 21st May
10:51 min for 200 swings - 27th May
9:40 min for 200 swings - June 1st
```

I think the longer time's in the early stage were taken at home, which explains the big jump. Lots of distractions at home!

So after that I jumped right in to 500 swings a day.

#### 500 Swings early times

My times shot down rapidly, and settled at around 25 minutes:

```
29:33 (8:03 - 200 Swings) June 9th
24:54 (7:47 - 200 swings) June 12th
25:11 (7:45 - 200 swings) June 16th
```

I also have been recording my 200 swing split also, as it's a good metric of how the rest of the session would go. For example I tried harder to get a good time on the 16th, but it left me gassed out and took some time off the final score.

So 500 swings a day. My DEXA scan is actually August 30th. So this is only 30 days or so.

I'm thinking it's going to be a few kilos lost, hopefully maybe 1 or 2% body fat, and I'm aiming to get my 500 swing time down to maybe 24:00 minutes and my 200 swing time down to at least 7 minutes. That seems optimistic in 30 days, definitely achievable in 90!

So in a month's time I'll check in, see how I feel. I'll probably be sick to death of kettlebells and try something new!

Next check-in on July 1st.

gha_language: SCSS


text:
---
layout: default
---

# 1996-02-02 - Re: RC2 Source Code - Legal Warning from RSADSI

## Header Data

From: "Brian A. LaMacchia"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: c69460ca27893682c1be7e4c020297d72d63fa118a1e96c4c821db5ff6b02d2b

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-02-02 02:30:40 UTC

Raw Date: Fri, 2 Feb 1996 10:30:40 +0800

## Raw message

```
{% raw  %}From: "Brian A. LaMacchia"<EMAIL_ADDRESS>Date: Fri, 2 Feb 1996 10:30:40 +0800
To<EMAIL_ADDRESS>Subject: Re: RC2 Source Code - Legal Warning from RSADSI
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

   Date: Thu, 1 Feb 1996 18:26:15 -0500
   Mime-Version: 1.0
   Content-Type: text/plain; charset="us-ascii"
   From<EMAIL_ADDRESS>(Jonathan Rochkind)
   Sender<EMAIL_ADDRESS>   Precedence: bulk

   Now, copyright might be another matter.    But you can't copyright an
   algorithm, only specific text in fixed form (ie, the source code).  So this
   would mean you couldn't use the particular code posted to sci.crypt, but
   wouldn't stop anyone from using the algorithm, if they wrote their own code
   (to be safe, without having seen the RSA-copyrighted code, only having the
   algorithm described to them by someone else).

If the source code posted to sci.crypt was in fact a copy of an RSADSI
copyrighted soure code listing, then making copies of that listing is a
copyright violation.  However, copyright protection does not extend to
the underlying algorithm, so unless RSADSI has a patent on the algorithm
the idea is free, and can be reimplemented using a "clean room" or
"Chinese wall" approach.  If the posted source code was *not* a copy of
RSADSI source code but instead produced by disassembling object code
RSADSI's claims are tenuous at best.  RSADSI could conceivably claim
that the disassembled code is a derivative product of their copyrighted
object code, but I think they would have a hard time distinguishing
themselves from the facts in _Sega v. Accolade_.

I fail to see how the legality of "alleged-RC2" is any different than
that of the "alleged-RC4" code which was published last year.

						--bal

{% endraw %}
```

## Thread

+ Return to [February 1996](/archive/1996/02)

+ Return to "["Brian A. LaMacchia" <bal@martigny.ai.mit.edu>](/authors/brian_a_lamacchia_bal_at_martigny_ai_mit_edu_)"
+ Return to "[Ernest Hua <hua@chromatic.com>](/authors/ernest_hua_hua_at_chromatic_com_)"
+ Return to<EMAIL_ADDRESS>(Jonathan Rochkind)](/authors/jrochkin_at_cs_oberlin_edu_jonathan_rochkind_)"

+ 1996-02-02 (Fri, 2 Feb 1996 19:02:12 +0800) - [Re: RC2 Source Code - Legal Warning from RSADSI](/archive/1996/02/c5f5caa1b1521febb3a345e5fd398de250b4e3690d27dd57bb4a924cbebcd035) -<EMAIL_ADDRESS>(Jonathan Rochkind)_
  + 1996-02-02 (Fri, 2 Feb 1996 08:51:54 +0800) - [Re: RC2 Source Code - Legal Warning from RSADSI](/archive/1996/02/6d545bd95e41ab33d3c2c681aad017e4abd5e19b8892ab14630e918b247a72b6) - _Ernest Hua<EMAIL_ADDRESS>  + 1996-02-02 (Fri, 2 Feb 1996 10:30:40 +0800) - Re: RC2 Source Code - Legal Warning from RSADSI - _"Brian A. LaMacchia"<EMAIL_ADDRESS>


text:
---
title: Raffles Place
permalink: /memories-of-two-cities-singapore/centres-of-commerce/raffles-place/
breadcrumb: Raffles Place
third_nav_title: Centres of Commerce
---
Originally known as Commercial Square, Raffles Place was designated as the business district of Singapore by Sir Stamford Raffles in 1822. Originally a swampy area, a hill had to be levelled to fill and construct the square.

The proximity of Commercial Square to the harbour at Collyer Quay and the Singapore River – the lifeline of Singapore’s entrepôt trade – gave rise to banks, trading agencies, shops, godowns (warehouses) and offices around the square. The imposing buildings of these commercial establishments lent an air of affluence and distinction to the area.

Raffles Place and its surrounding areas have undergone tremendous change over time. However, it remains the heart of Singapore’s financial district.

Fullerton Square, 1900s

Courtesy of National Archives of Singapore

19980005093 - 0074

Fullerton Square was a busy thoroughfare that connected Collyer Quay – once the landing point for ships to unload and store their goods, and for passengers to disembark – to Commercial Square (later known as Raffles Place), the business hub of early Singapore. The Hongkong and Shanghai Bank building is visible on the right.

Fullerton Square and Battery Road, c. 1900

National Archives of the Netherlands Collection, courtesy of National Archives of Singapore

20060000334 - 0088

Seen here is the Tan Kim Seng Fountain at Fullerton Square. The Victorian-style structure was built in 1882 to commemorate the prominent merchant and philanthropist’s contributions to Singapore’s waterworks. Leading away from the fountain is Battery Road, which connected Collyer Quay to Commercial Square, making it one of the busiest streets in Singapore in the 19th and early 20th centuries.

Battery Road, 1880s

Lee Kip Lin Collection, National Library Singapore

The mercantile community on Battery Road was made up of mainly European merchants and traders. In the late 19th century and early 20th century, the street was lined with three-storey and four-storey buildings that housed shops, offices, warehouses and banks.

Battery Road, 1920s

Anthony Wharton Collection, courtesy of National Archives of Singapore

19980005034 - 0095

The Medical Hall, as seen on the left, was a landmark at the corner of Fullerton Square and Battery road for many years. It was also known as the Red House because of its red brick façade. Like many of the early dispensaries in Singapore, Medical Hall was opened by
European doctors, in this case, by German doctor Christopher Trebing in the 1870s. The building was demolished in 1970.

Battery Road in the evening, 1954

Donald Moore Collection, courtesy of National Archives of Singapore

20140000145 - 0042

Raffles Place, 1880s

Lee Kip Lin Collection, National Library Singapore

Originally known as Commercial Square, Raffles Place was designated as a business centre for the mercantile community by Sir Stamford Raffles in 1822. It was renamed Raffles Place in 1858 to commemorate his contributions.

Raffles Place, 1920s

Andrew Tan Collection, courtesy of National Archives of Singapore

19980005901 - 0023

In the early 20th century, Raffles Place was a bustling commercial area with never-ceasing traffic, bordered by imposing buildings that housed banks, offices and department stores. Seen here is the Chartered Bank building in the centre and the façade of John Little,
the oldest department store in Singapore, on the right.

Raffles Place seen from Chartered Bank, 1920s

Courtesy of National Archives of Singapore

19980005784 - 0023

The square of Raffles Place was originally a garden before it was turned into a carpark in the early 1900s, with the Mercantile Bank building located on its southern end. On the right of the image stands the Raffles Chambers, with its distinctive statue of Eros that adorned its façade. Built in 1912 to house the retail store of Katz Brothers, it would go on to become the home of leading local department store, Robinsons & Co., which moved into the building in 1941.

Raffles Place, 1966

Ministry of Information and the Arts Collection, courtesy of National Archives of Singapore

19980005179 – 0082

Following the completion of an underground carpark at Raffles Place by 1965, the open-air carpark was transformed into a park featuring fountains and a giant flower clock. In the 1980s, the underground carpark was demolished to make way for the Raffles Place underground train station.

repository: isomerpages/nlb-photo-exhibition

branch_name: refs/heads/staging

gha_license_id: NOASSERTION

repo_name: isomerpages/nlb-photo-exhibition


text:
# [OpenCV 3.4.3 images for Docker](https://hub.docker.com/r/niekvb/opencv-3.4.3 "View on Docker Hub")

OpenCV 3.4.3 images for different programming languages installed on several operating systems.

## Images & supported tags

- `python-3.7.3_raspbian-stretch` ([Dockerfile](https://github.com/niekvb/docker-opencv/blob/master/3.4.3/python-3.7.3_raspbian-stretch.dockerfile "View dockerfile"))

## About this repository

Belongs to the repository [OpenCV images for Docker](https://github.com/niekvb/docker-opencv "View on GitHub") on GitHub.

Author: *Niek van Bennekom*

Copyright: [Niekvb Media](https://www.niekvb.com/ "Go to website") © 2019

Licensed under the [MIT license](https://github.com/niekvb/docker-opencv/blob/master/LICENSE "View license").

repository: niekvb/docker-opencv

repo_name: niekvb/docker-opencv


text:
# TD3 DRL Algorithm operating in simglucose simulator

An implementation of the twin delayed deep deterministic policy gradient algorithm  designed as a controller
for simglucose.
based on
@inproceedings{fujimoto2018addressing,
  title={Addressing Function Approximation Error in Actor-Critic Methods},
  author={Fujimoto, Scott and Hoof, Herke and Meger, David},
  booktitle={International Conference on Machine Learning},
  pages={1582--1591},
  year={2018}
}

This simulator is a python implementation of the FDA-approved [UVa/Padova Simulator (2008 version)](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4454102/) for research purpose only. The simulator includes 30 virtual patients, 10 adolescents, 10 adults, 10 children.
Jinyu Xie. Simglucose v0.2.1 (2018) \[Online\]. Avaible: https://github.com/jxx123/simglucose. Accessed on: Month-Date-Year.

 - Note: simglucose only supports python3.

repository: alanmackey/DRL-for-BG-Control

repo_name: alanmackey/DRL-for-BG-Control


text:
# MyGift

## Disclaimer

Other websites already exist and do exactly what I plan to do. The idea here
is to develop it for training purpose. There is nothing serious behind. Feel
free to contact me if you want to participate in some way.

## Purpose

I want to have a website that allow to create a wishlist, share it with friends.
On top of that, I plan to have "events" that allow either some people to buy stuff
to one people (birthday) or people to offer gifts each other (christmas). Basically
you can say "I, or we want to buy this" and avoid two people buying it. Of course
what you will receive will be hide to you. As a buyer, you will also have the possibility
to have a "buy list".

As of now, the website is quite limited but allows you to:

- Create and manage your own wishlist
- Add friends and manage your friend list
- Access to your friend wishlist
- As a friend, be able to say I am interested, I want to buy, or I have bought a given gift
- A buy list that summarize all you have to buy and already bought
- As a friend, add/propose secretly a gift

## Things that need upgrade

You can check already booked issue here in GitHub but there is more.

# How to build and other

## Build

```bash
gradlew test jar
```

This command will only build jar individually and run the tests.

```bash
gradlew shadowJar
```

This command will package the two shadow jar of this application. It depends how you want to deploy the application (fat
jar or classpath).

There are two jars

- auth-server-<version>-all.jar: shadow jar for the authentication server;
- back-<version>-all.jar: shadow jar for backend. Note that this jar embedded also the front end;

## Generate JKS for Https & SSL support

- Download private key and ssl cert from your vendor
- Rename them with extension .pem
- https://ktor.io/quickstart/guides/ssl.html
    - openssl pkcs12 -export -out ./keystore.p12 -inkey ./key.pem -in cert.pem -name <name>
    - choose password, it will correspond to alias password
    - keytool -importkeystore -alias <alias> -destkeystore ./mygift.jks -srcstoretype PKCS12 -srckeystore ./keystore.p12
    - choose password, it will correspond to jks password

## Activate foreign-keys on sqlite3

To check if activated: "PRAGMA foreign_keys;"
To activate in case not activated: "PRAGMA foreign_keys = ON;"

repository: AnthonyPoncet/mygift

gha_language: Kotlin

repo_name: AnthonyPoncet/mygift


text:
---
layout: post
title: Proposal Draft Feedback
categories: [university]
tags: [honours]
description: Feedback on my proposal work so far.
---

Over the course of this afternoon, my friend Daniel Boyd has thoroughly looked over and read my proposal as it currently stands, and provided feedback for the document. Using Google Docs for the current version, he highlighted sections for me and wrote comments on the sections describing what changes/updates I should do for them, and provided general feedback at the bottom of the document - he also talked through the document with me.

I also received an email from Matt Bett today saying that he looked over my first draft, and he said that everything looked fine and that all the content that he would look for was there - so overall my structure seems to be okay.

I have implemented the changes suggested by Daniel, which only involved tweaks to the document here and there and means that I have kept all of the content from what Matt has seen, and have only really added to the document since he has seen it.


text:
Direct Wmode
============
An userscript to make flash object display in "direct" mode.

After installing the script, you should add custom domains yourself.

Changelog
---------
* Version 0.1.1 (2015/4/1)
	- Add include rule.
* Version 0.1.0 (2015/4/1)
	- Release.


text:
---
id: context
title: Context
sidebar_label: Context
---

In GraphQL, a Context is an object shared by all the resolvers of a specific execution. It's useful for keeping data such as authentication info, the current user, database connection, data sources and other things you need for running your business logic.

The `context` is available as 3rd argument of each resolver:

```typescript
const resolvers = {
    Query: {
        myQuery: (root, args, context, info) => {

        },
    },
};
```

> You can read more about resolver in **[Apollo Server documentation](https://www.apollographql.com/docs/graphql-tools/resolvers#Resolver-function-signature)**.

GraphQL Modules also uses the `context`, and it add to the context a field called `injector`, which you can use to get access to the dependency injection container of your `GraphQLModule`.

You can use the `injector` from any resolver like that:

```typescript
import { ModuleContext } from '@graphql-modules/core';

export default {
    Query: {
        myQuery: (_, args, { injector }: ModuleContext) =>
            injector.get(MyProvider).doSomething(),
    },
};
```

### Context Builders

In addition to the added `injector`, GraphQL Modules let you add custom fields to the `context`.

Each module can have it's own `context` function or object, which get's the network session that contains request, the current `context`, and the `injector` and can extend the GraphQL `context` with any field.

To add a custom `context` to your `GraphQLModule` do the following:

```typescript
import { GraphQLModule } from '@graphql-modules/core';
import * as typeDefs from './schema.graphql';
import resolvers from './resolvers';

export interface IMyModuleContext {
    myField: string;
}

export const MyModule = new GraphQLModule<{}, {}, IMyModuleContext>({
    typeDefs,
    resolvers,
    context: (session, currentContext, moduleSessionInfo) => {
        return {
            myField: 'some-value',
        };
    },
});
```

> Your custom context building function should return either `object` or `Promise<object>`.

Then, in any of your resolvers, you can access it this way:

```typescript
import { ModuleContext } from '@graphql-modules/core';
import { IMyModuleContext } from './my-module';

export default {
    Query: {
        myQuery: (_, args, { myField }: ModuleContext<IMyModuleContext>) =>
            injector.get(MyProvider).doSomething(myField),
    },
};
```

You can also use this feature to implement authentication easily, because you have access to the network session, you can write async code, and you can return the current user and add it to the `context`, for example:

```typescript
import { GraphQLModule, Injector } from '@graphql-modules/core';
import * as typeDefs from './schema.graphql';
import resolvers from './resolvers';
import { AuthenticationProvider } from './auth-provider';

export interface User {
  firstName: string;
  lastName: string;
}

export interface ISession {
  req: express.Request;
  res: express.Response;
}

export const AuthModule = new GraphQLModule({
    typeDefs,
    resolvers,
    providers: [
      AuthenticationProvider,
    ],
    async context(session: ISession, currentContext, { injector }) {
        const authToken = session.req.headers.authentication;
        const currentUser = injector.get(AuthenticationProvider).authorizeUser(authToken);
        return {
            currentUser,
        };
    },
});
```

You can read more about **[authentication and how to implement it here](https://medium.com/the-guild/authentication-and-authorization-in-graphql-and-how-graphql-modules-can-help-fadc1ee5b0c2)**.

repository: Zzeris/graphql-modules

repo_name: Zzeris/graphql-modules


text:
# UITestHelper
A bunch of utility scripts intended to address some of the common problems in iOS Unit Testing and UI Testing

## uitestrunner.sh
This script is aimed at mitigating the flakiness of UITests in iOS. In the case of UITests, it often happens that some tests might fail when the entire test suite is run, but the same tests will pass when ran in isolation.
The script re-runs the failed tests a fixed number of times until they pass.
It accepts the following arguments:
* c: Parallel Testing Workers Count (Do not pass if parallel testing not intended)
* w: Workspace of the project
* d: Destination of the test (e.g. platform=iOS Simulator,name=iPad Pro (12.9-inch),OS=12.2)
* t: Target of the project (e.g. YourApp_UITests)
* l: Retry Limit; The number of retries that you want the program to run.

### Dependencies
* MacOS with Xcode commandline tools installed Xcode version (>=10.2)
* PLISTBUDDY (usually comes with the macOS)


text:
# Welcome to Cookie Explorer!

This is a simple implementation of fetching the cookies from the WebEngine
Cookie Store.

Require Qt 5.6 and up and only tested on MacOS with Qt 5.10 ( but should work on other
platforms )

## Build

`mkdir -p build && cd build && cmake .. && make && cd -`

## Run

`build/CookieExplorer https://website.com/`

repository: geffrak/CookieExplorer

repo_name: geffrak/CookieExplorer


text:
# flutter_chore

  A flutter package for invoking a certain block of code only a fixed amount of times.

## 1. Installation

1.1.1 Add flutter_chore to your pubspec.yaml file:
```yaml
    dependencies:
        flutter_chore: 0.0.4
```
1.1.2 Run flutter packages get to install the package.

## 2. Usage

### 2.1 Initialize the package
2.1.1 Import Flutter Chore with:
```dart
    import 'package:flutter_chore/flutter_chore.dart';
```
2.1.2 Initialize the package:
```dart
    await Chore.init();
```

### 2.2 Use the package
2.2.1 Using the Chore.newChore method:
```dart
    Chore.newChore(
          "chore_mark",
          (int time) {
            // do something only 4 times
          },
          times: 4,
        ).run();
```
2.2.2 Using the Chore.builder method:
```dart
    Chore.builder()
         .invoke((int time) {
            // do something only 4 times
         })
         .times(4)
         .mark("mark")
         .run();
```
other methods:
```dart
    Chore.builder()
         .invoke((int time) {
            // do something only 1 time
         })
         .once()
         .mark("chore_mark")
         .run();

    Chore.builder()
         .invoke((int time) {
            // do something only 2 times
         })
         .twice()
         .mark("chore_mark")
         .run();

    Chore.builder()
        .invoke((int time) {
            // do something only 3 times
         })
        .thrice()
        .mark("chore_mark")
        .run();
```
2.2.3 Using the once, twice, and thrice methods:
```dart
    Chore.once("chore_mark", () {
          // do something only 1 time
        }).run();

    Chore.twice("chore_mark", (int time) {
          // do something only 2 times
        }).run();

    Chore.thrice("chore_mark", (int time) {
          // do something only 3 times
        }).run();
```
2.2.4 Listen for events:
```dart
Chore.newChore(
      "chore_mark",
      (time) {
        // do something only 5 times
      },
      times: 5,
    ).run().onSecondTime(() {
      // do something before doing the chore for the second time
    }).beforeLastTime(() {
      // do something before doing the chore for the last time
    }).ifDone(() {
      // do something after the chore has been done as many times as set in the 'times' field
    });
```
2.2.3 Get a list of all registered chores:
```dart
    List<ChoreItem> chores = Chore.getAllChores();
```

# License
```xml
Copyright 2021 mustafadakhel (Mustafa Muhammed Dakhel)

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.
```

repository: mustafadakhel/Flutter-Chore

repo_name: mustafadakhel/Flutter-Chore


text:
# Template: Salesforce new case to Google Sheet
When a new case in Salesforce is created, creates Sheet in Googel Sheets  <br>

This integration template helps to create a spreadsheet for each new cases in salesforce. There is a listner in the template.
It listen the changes happens for a case record in salesforce. If there is a new case created in the
salesforce then this template fetch all data of that case record and create a spreadsheet with the case information.

![image](docs/images/sfdccase2gsheet.png)

## What you need

- [Ballerina Distribution](https://ballerina.io/learn/getting-started/)
- A Text Editor or an IDE ([VSCode](https://marketplace.visualstudio.com/items?itemName=ballerina.ballerina),
[IntelliJ IDEA](https://plugins.jetbrains.com/plugin/9520-ballerina)).
- [Salesforce Connector](https://github.com/ballerina-platform/module-ballerinax-sfdc) and [GSheet Connector](https://github.com/ballerina-platform/module-ballerinax-googleapis.sheets) will be downloaded from
[Ballerina Central](https://central.ballerina.io/) when running the Ballerina file.

## How to set up

Let's first see how to add the Salesforce configurations for the application.

### Setup Salesforce configurations
Create a Salesforce account and create a connected app by visiting [Salesforce](https://www.salesforce.com).
Obtain the following parameters:

* Base URL (Endpoint)
* Client Id
* Client Secret
* Refresh Token
* Refresh URL

For more information on obtaining OAuth2 credentials, visit
[Salesforce help documentation](https://help.salesforce.com/articleView?id=remoteaccess_authenticate_overview.htm)
or follow the
[Setup tutorial](https://medium.com/@bpmmendis94/obtain-access-refresh-tokens-from-salesforce-rest-api-a324fe4ccd9b).

Also, keep a note of your Salesforce username, password and the security token that will be needed for initializing the listener.

For more information on the secret token, please visit [Reset Your Security Token](https://help.salesforce.com/articleView?id=user_security_token.htm&type=5).

[Select Objects](https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_select_objects.htm) for Change Notifications in the User Interface of Salesforce account.

Now let's see how to add Google Sheet configurations
### Setup Google Sheet configurations
Create a Google account and create a connected app by visiting [Google cloud platform APIs and Services](https://console.cloud.google.com/apis/dashboard).

1. Click `Library` from the left side menu.
2. In the search bar enter Google Sheets.
3. Then select `Google Sheets API` and click `Enable` button.
4. Complete OAuth Consent Screen setup (Add required mais as a test user ).
5. Click Credential tab from left side bar. In the displaying window click Create Credentials button
Select OAuth client Id.
6. Fill the required field. (Add https://developers.google.com/oauthplayground/ to the Redirect URI field if you want
to use [OAuth 2.0 Playground.](https://developers.google.com/oauthplayground/) for accesstoken generation).
7. You can get credentials using `Credentials` tab in left side bar.
8. Generate access token and refresh token using these credentials ( You can use [OAuth 2.0 Playground.](https://developers.google.com/oauthplayground/) to generate them.)

Get more details about createing OAuth 2.0 client credentials,  [visit here](https://developers.google.com/sheets/api/guides/authorizing)

Obtain the following parameters:

* Client Id
* Client Secret
* Refresh Token
* Refresh URL

## Confuring the Integration Template

Once you obtained all configurations, Replace "" in the `Config.toml` file with your data.

#### Config.conf
```
[<ORG_Name>.sfdc_new_case_to_gsheet]
sfdcBaseURL = "<Salesforce Base URL>"
sfdcUsername = "<Salesforce Username>"
sfdcPassword = "<Salesforce Password>"
sfdcClientId = "<Client Id>"
sfdcClientSecret = "<Client Secrets>"
sfdcRefreshToken = "<Refresh Token>"

[<ORG_Name>.sfdc_new_case_to_gsheet.sheetOAuthConfig]
clientId = "<Sheet client Id>"
clientSecret = "<Sheet client secret>"
refreshUrl = "<Sheet refresh URL>"
refreshToken = ""<Sheet refresh token>""

```
## Running the Template

1. First you need to build the integration template and create the executable binary. Run the following command from
the root directory of the integration template.
`$ bal build`.

2. Then you can run the integration binary with the following command.
`$ bal run target/bin/sfdc_new_case_to_gsheet.jar`.

Once you run, successful listener startup will print following in the console.
```
>>>>
[2021-01-27 13:02:32.879] Success:[/meta/handshake]
{ext={replay=true, payload.format=true}, minimumVersion=1.0, clientId=2qw18mvbp4r5o16025e384re8hk7, supportedConnectionTypes=[Ljava.lang.Object;@7dd62bd0, channel=/meta/handshake, id=1, version=1.0, successful=true}
<<<<
>>>>
[2021-01-27 13:02:33.040] Success:[/meta/connect]
{clientId=2qw18mvbp4r5o16025e384re8hk7, advice={reconnect=retry, interval=0, timeout=110000}, channel=/meta/connect, id=2, successful=true}
<<<<
```

3. Now you can create a new Salesforce Case and observe that integration template runtime has received the event notification for the created Salesforce Case.

4. Also you can check the Google drive , there will be a new spreadsheet with Case Number as the spreadsheet name .

repository: dnnaji/choreo-samples

repo_name: dnnaji/choreo-samples


text:
---
layout: post
title: "Function-Currying"
date: 2013-02-15 09:35
comments: true
categories: [functions, python, currying, partials, functools]
---

Recently I have been looking into functional languages such as Haskell and one of the things
I really like about Haskell is function currying / partial application. Python has this as
well.
``` python
from functools import partial
def func(x, y, z):
    return (x, y, z)

part = partial(func, 1)
```
However I find this syntax to be a bit ugly. I would prefer to just be able to call a function with
only a portion of its arguments and have it generate a new function that takes in the other arguments.
``` python
def func(x, y, z):
    return (x, y, z)

part = func(1)
```
That syntax just seems a lot cleaner to me. In order to implement this syntax I wrote a small
decorator which can be placed on a function and adds the built in currying functionality.
``` python curry decorator
class curry(object):
    """
    Decorator which takes a int which is the maximum number of args the decorated function can take
    """
    def __init__(self, numArgs):
        self.numArgs = numArgs

    def __call__(self, func):
        if self.numArgs > 0:
            @curry(self.numArgs-1)
            def wrapper(*args, **kwargs):
                if len(args) < self.numArgs:
                    return partial(func, *args)
                else:
                    return partial(func, *args)(**kwargs)
            return wrapper
        else:
            return func
```

This decorator takes in the number of arguments for the function and then recursively wraps the function.
Every time an argument is added to the function it recurses down another layer until all arguments have been added the the function.
It then calls the original function with all its arguments. The final syntax looks like this.
``` python
@curry(3)
def func(x, y, z):
    return (x, y, z)

part1 = func(1)
part2 = part1(2)
result = part2(3)
```
This code and the code for the pipelines mentioned in the previous post are hosted on my [github page](https://github.com/rossdylan/utils).

extension: markdown


text:
---
layout: post
title: "Delta Beta Testing"
date: 2016-12-08 22:33:29 -0800
comments: true
category: blog
author: riley
tag:
- developer
- delta
---

[In my last post](http://rileytestut.com/blog/2014/10/07/gba4ios-is-dead-long-live-gba4ios/), I explained that GBA4iOS was more or less dead after Apple released iOS 8.1, which killed the date trick used to install the app. Now, two years later, I’m finally writing another post to confirm that GBA4iOS is finally, truly, dead.

And it feels great to say that.

GBA4iOS was a tremendous success; by the time it was finally killed, it had been downloaded over *twenty-five million times*, which still blows my mind. Clearly there’s a market for emulators on iOS, despite Apple’s policies excluding them from the App Store. However, for many reasons it made sense to let GBA4iOS die, so that’s exactly what happened (for one, GBA4iOS 2.0 was released when I was a senior in high school, when I had plenty of free time; now, I’m a junior studying Computer Science at the University of Southern California ✌).

Eventually though, I began to wonder what I would work on next, and in March 2015 I wrote my first line of code on what would become GBA4iOS’ successor: **Delta**.

<!-- more -->

## So, what is Delta?

Delta is an upcoming emulator for iOS devices that I have been working on for the past couple of years. Unlike GBA4iOS, Delta will not just emulate one (or two) systems; instead, Delta will emulate an array of game consoles, starting with Game Boy (Color), Game Boy Advance, Super Nintendo, and Nintendo 64. (Additionally, more consoles will be added in the future, so if you have any in particular you’d like to see added, please let me know in the comments or [on Twitter](https://twitter.com/rileytestut).)

I originally teased Delta last February at the end of a [video made to celebrate GBA4iOS’ two year anniversary](https://www.youtube.com/watch?v=vOSvWpXydu0). Following several months of silence, I released a teaser webpage for what will eventually become Delta’s home, [http://deltaemulator.com](http://deltaemulator.com). I promised that beta testing of Delta would begin in December, and now that we’re just over a week into the month, it’s time to finally start that process.

## How do I apply?

Just like with GBA4iOS, there will be two main groups of beta testers: **general** and **press**. The differences between the two are minor, but press beta testers will be for those who will write or post some original content about the betas (vlogs included!). Because of this, they will also be provided with betas more often than general testers, as they need to be kept constantly up to date.

For both groups though, there are a couple of **prerequisites**:

- At least one device running iOS 10
- Apple ID (for TestFlight builds)

Assuming you meet these (minimal) requirements, all you need to do is fill out this form, and you’ll be considered for one of the beta testing slots:

[Delta Beta Test Application](https://docs.google.com/forms/d/e/1FAIpQLSe3iSp6A8i-Y2khVujO4RBQvo6r37dDat33yghdhrzqpZs48g/viewform)

We’ll be accepting beta test applications until next **Friday, December 16, at 11:59pm**, and testers will be announced the following **Monday, December 19**, at which point we’ll also release the first beta.

## But wait, there’s more!

This time around we’re also holding an (optional) competition for those applying for general beta testing. We’re looking to promote Delta soon, and rather than using our own promotional artwork, we’d love to use stuff that y’all have designed yourselves!

If you’re interested in participating, simply upload **any original piece of content** promoting Delta when applying for general beta testing, and we’ll pick our favorite submissions to promote Delta as we approach launch. We’re open to pretty much anything, so **images, videos, motion graphics, etc.** are all valid! And of course, if your art is selected, you will also be chosen to beta test the app.

For your convenience, we’ve uploaded some Delta assets that you are more than welcome to use in your submissions, which can be found [here](http://deltaemulator.com/assets).

## Improving your chances

You might be wondering if there’s anything that can improve your chances, especially since we’re expecting a large number of submissions. Luckily, there are a few (completely optional) things you can do!

- [Follow me on Twitter](https://twitter.com/rileytestut), as well as fellow judges [Caroline Moore](https://twitter.com/1carolinemoore), [Grant Gliner](https://twitter.com/grantgliner), and [Maddie McCarthy](https://twitter.com/maddiemccarcar).
- [Retweet this tweet](https://twitter.com/rileytestut/status/807332824189501440) linking back to this blog post.
- Submit artwork for the promotional artwork competition mentioned above.
- Have an iOS developer account.

## Wrap-Up

I’m thrilled to finally be openly talking about Delta, and I couldn’t be more excited to put it in your hands for the first time ever. I wish you all the best of luck applying, and can’t wait to start getting your feedback so I can have it ready to release to everyone as soon as possible. Looking forward to hearing from each of you!

repository: rileytestut/indigo

branch_name: refs/heads/gh-pages

repo_name: rileytestut/indigo


text:
# HP-GMN: Graph Memory Networks for Heterophilous Graphs

```
@inproceedings{hpgmn_icdm22,
title = {HP-GMN: Graph Memory Networks for Heterophilous Graphs},
author = {Junjie Xu and Enyan Dai and Xiang Zhang and Suhang Wang},
booktitle = {22nd {IEEE} International Conference on Data Mining (ICDM)},
pages = {1263--1268},
year = {2022}
}
```

links
- [ieee](https://doi.org/10.1109/ICDM54844.2022.00165)
- [arxiv](https://arxiv.org/abs/2210.08195)

gha_language: Jupyter Notebook


text:
# Pre-work - SimpleTodo

SimpleTodo is an android app that allows building a todo list and basic todo items management functionality including adding new items, editing and deleting an existing item.

Submitted by: Ganesh Ragavan Narayanan

Time spent: 15 hours spent in total

## User Stories

The following **required** functionality is completed:

* [*] User can **successfully add and remove items** from the todo list
* [*] User can **tap a todo item in the list and bring up an edit screen for the todo item** and then have any changes to the text reflected in the todo list.
* [*] User can **persist todo items** and retrieve them properly on app restart

The following **optional** features are implemented:

* [*] Persist the todo items [into SQLite](http://guides.codepath.com/android/Persisting-Data-to-the-Device#sqlite) instead of a text file
      Please refer TaskDbHelper class in my github for the database definitions.
* [*] Improve style of the todo items in the list [using a custom adapter](http://guides.codepath.com/android/Using-an-ArrayAdapter-with-ListView)
      Please refer CustomAdapter class in my code.
* [*] Add support for completion due dates for todo items (and display within listview item)
	  I started with using DatePicker, but it was occupying lot of space in the screen.  So I ended up using a string for the date.  I have
	  added support for editing this date field as well.
* [*] Use a [DialogFragment](http://guides.codepath.com/android/Using-DialogFragment) instead of new Activity for editing items
      I have implemented this using AlertDialog.  When a item needs to be edited, AlertDialog pops up to edit the selected todo item.  It has options
      to Cancel the request, Delete the todo item and Edit the todo item.
* [*] Add support for selecting the priority of each todo item (and display in listview item)
      I have used Spinner with high/medium/low values.  Please refer activity_main2.xml
* [*] Tweak the style improving the UI / UX, play with colors, images or backgrounds
	  I have used "+" image for add a todo item and added background colour.

The following **additional** features are implemented:

* [ ] List anything else that you can get done to improve the app functionality!

## Video Walkthrough

Here's a walkthrough of implemented user stories:

<img src='http://i.imgur.com/2K1zHLG.gif' title='Video Walkthrough' width='' alt='Video Walkthrough' />

GIF created with [LiceCap](http://www.cockos.com/licecap/).

## Project Analysis

As part of your pre-work submission, please reflect on the app and answer the following questions below:

**Question 1:** "What are your reactions to the Android app development platform so far?
 Compare and contrast Android's approach to layouts and user interfaces in past platforms you've used."

**Answer:**

Android app development is lot of fun.  Especially with Android Studio, it makes it very convenient to develop apps.
RelativeLayout view group displays child views in relative positions.  With this, designing the layouts and user interfaces becomes simpler
and I can concentrate on the business logic.  I had used .NET framework earlier, but I found Android layouts and user interfaces to be more
friendly and easier to use.  With the auto completion feature provided by Android Studio it makes it much more convenient to get the
defined variables and methods.

**Question 2:** "Take a moment to reflect on the `ArrayAdapter` used in your pre-work. How would you describe an adapter in this context and
 what is its function in Android? Why do you think the adapter is important? Explain the purpose of the `convertView` in the `getView` method
  of the `ArrayAdapter`."

**Answer:**

Suppose you have say 1000 contacts that you want to display in the screen.  All the entries will not fit in a phone screen or even in a tab.  The
number of entries that will fit in a phone screen is different from that will fit in a tab.  So we want some mechanism to display the objects
(numbers, strings, custom types, etc.) in the screen.  For this Adapter is used which provides the data that will be shown on a ListView, GridView,
Spinner, etc.  ArrayAdapter is the simplest adapter because the adapter converts an ArrayList of objects into View items loaded into the
container (ListView, GridView, etc.).  The ArrayAdapter fits in between an ArrayList (data source) and the ListView (visual representation) and configures
array to use as the data source for the list and how to convert any given item in the array into a corresponding View object.

In my implementation, I have used Custom Adapter which uses DataModel class to provide the data.  DataModel object is populated by reading values
from SqlLite database.  The convertView parameter is a recycled instance of todo items ListView that was previously returned from getView().
The first time that getView() is  called, convertView is guaranteed to be null, as you have not yet created a View to be recycled.
When one of your Views in the list have been scrolled offscreen and are no longer visible to the user, they are removed from the ViewGroup and added
to the internal recycling bin. In my implementation getView() inflates the item_todo TextView (defined in item_todo.xml) that displays the task name
and the priority.

## Notes

Describe any challenges encountered while building the app.

I encountered the below challenges:

1. I was finding it challenging to get the MainActivity's context from the custom adapter. This was needed to open up the AlertDialog to
   edit the items when a todo task is clicked from the MainActivity's ListView.  Then I resolved this by passing MainActivity.this to the
   Custom Adapter constructor and retrieving this context when needed.  I was needing the MainActivity's context to call a method defined
   in the MainActivity.
2. The layout that I defined in the xml file was not aligning properly.   Then I starting editing using "Design" tab of xml file to get the
   alignment properly.
3. I was getting "app closed" error when I try to run the app.  Then I looked into the stack trace and resolved the issue.
4. I tried using date time picker, but for some reason it was occupying a lot of space in the screen and I was not able to see the buttons
   below.

## License

    Copyright [2017] [Ganesh Ragavan Narayanan]

    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.

repository: ganeshragnarayanan/todoapp

repo_name: ganeshragnarayanan/todoapp


text:
### [Paper](https://arxiv.org/abs/2102.03099) | [UAVid2020 Benchmark](https://competitions.codalab.org/competitions/25224)

Pytorch implementation of our paper [Bidirectional Multi-scale Attention Networks for Semantic Segmentation of Oblique UAV Imagery](https://arxiv.org/abs/2102.03099).

Our code is based on [Hierarchical Multi-Scale Attention for Semantic Segmentation](https://arxiv.org/abs/2005.10821).[[github]](https://github.com/NVIDIA/semantic-segmentation)

## Installation

* The code is tested with pytorch 1.3 and python 3.6

## Download Weights

* Create a directory where you can keep large files. Ideally, not in this directory.
```bash
  > mkdir <large_asset_dir>
```

* Update `__C.ASSETS_PATH` in `config.py` to point at that directory

  __C.ASSETS_PATH=<large_asset_dir>

* Download pretrained weights from [google drive](https://drive.google.com/open?id=1fs-uLzXvmsISbS635eRZCc5uzQdBIZ_U) and put into `<large_asset_dir>/seg_weights`

## Download/Prepare Data
Download UAVid data [download](https://uavid.nl/#download), then update `config.py` to set the path:
```python
__C.DATASET.UAVID_DIR = <path_to_uavid>
```

## Running the code

The instructions below make use of a tool called `runx`, which we find useful to help automate experiment running and summarization. For more information about this tool, please see [runx](https://github.com/NVIDIA/runx).
In general, you can either use the runx-style commandlines shown below. Or you can call `python train.py <args ...>` directly if you like.

## Train a model

Train uavid2020, using deeplabV3+ + WRN-38 + bidirectional multi-scale attention with pretrained model
```bash
> python -m runx.runx scripts/train_uavid_deepv3MS_bimsa.yml -i
```

## Run inference on UAVid

```bash
> python -m runx.runx scripts/eval_uavid_deepv3MS_bimsa.yml -i
```

Before running inference, path for the snapshot model needs to be configured in cfg file "eval_uavid_deepv3MS_bimsa.yml",

    snapshot: <path_to_file.pth>

The output inference will be saved in directory:

    logs/eval_uavid_deepv3MS_bimsa/<random folder name>/submit

The output label images from the model is 8 bit, which need to be converted to 24 bit for evaluation.
A simple script for conversion is provided. Inplace conversion is applied to all images in the specified folder recursively.

```bash
> python utils/img_conversion.py -d ./logs/eval_uavid_deepv3MS_bimsa/<random folder name>/submit/
```

You could just zip the subfolders for online benchmark submission.

Example of blended output is as follows,
![alt text](imgs/blendseq22000900.png "example inference")

### Pretrained Weights
The link to our trained weights with 70.8% mIoU score are as provided from google drive,

    https://drive.google.com/file/d/1jMVOHfHtO-z_eIq9cmA2GTo_MPF02ars/view?usp=sharing

## Citation

If you use this toolbox or benchmark in your research, please cite this project.

```
@article{mmdetection,
  title   = {Bidirectional Multi-scale Attention Networks for Semantic Segmentation of Oblique UAV Imagery},
  author  = {Ye Lyu and George Vosselman and Gui-Song Xia and Michael Ying Yang},
  journal = {arXiv preprint arXiv:2102.03099},
  year    = {2021}
}
```


text:
---
id:<PHONE_NUMBER>
key: getting_started_iot
title: "Getting started with microcontrollers and Google Cloud IoT Core"
level: intermediate
talkType: talk
language: english
tags:
  - iot
speakers:
  - gautier_mechling
presentation: https://drive.google.com/open?id=1klG35QuE8KlYm8nR3rrvYNxCfqbuuDuI
videoId: nTSLNN7qP2c
draft: false
---

## Description

In this talk, we will start from a famous and affordable microcontroller unit.
We will first discover how to write code for this MCU so we can get environment data. Then we will connect the microcontroller to the Cloud using Google Cloud IoT Core.
Our goal is to discover what these online Cloud IoT solutions offer, and why you may (or may not) need those.

We will focus on Google Cloud IoT core, core concepts remaining the same on other online platforms.

gha_language: JavaScript


text:
# Grid Analyzer

This is a simple Java application (*very* simple java application) that explores a small puzzle or game I always played
when I was a kid. The rules of this game are as follows:

* Imagine you have a grid of n by m, given n and m are positive integers
* Beginning in the top left corner of the grid, move diagonally from point to point
* If you reach the edge of the grid, move in the opposite direction of that edge (so move left when you reach the right
edge, or move up when you reach the bottom edge, etc.)
* Continue moving in this way until you reach a corner of the grid

I would play this game in my spare time in my mind while looking at grid-styled walls and floors. I always wondered what
the various properties of each grid was and how they relate to other grids that I could come up with. If you always
begin in the top left corner, which types of grids have paths that terminate in the opposite corner, or one of the
other two corners? Is there any grid that terminates in the same corner it started? What properties of that grid cause
it to be so?

So I started tinkering around with things and made this simple program to explore what those grids look like and see
how they may relate to each other. I have a few hypotheses concerning these grids:

1. The path of any n by m grid is congruent to another l by h grid where l = kn and h = km, where k is a positive integer
2. Given that hypothesis 1 is true, the only unique grids are those where n and m are co-prime. All paths of any grid l by h
are completely congruent and therefore can be reduced to the grid n by m, given l = kn and h = km and k is a positive integer.
3. The n by n grid
    * Always has perfectly symmetric paths (that is, the path starting in the top left corner will be symmetric horizontally
    and vertically to the path starting on the bottom left corner of the grid)
    * All paths in this grid end in the opposite corner they start (see hypothesis 5)
4. Grids of n by n + 1
    * The path originating in the top left corner of the grid terminates on the top right corner when n is even
    * The path originating in the top left corner of the grid terminates on the bottom left corner when n is odd
5. Grids of n by 2k + 1 always have paths that terminate in the bottom right corner, given the path starts in the top left
corner and k is a natural number.
6. The path in the n by m grid is a simple transformation of the path in the m by n grid.

Feel free to copy this source code and use it how you would like. If anyone else has puzzled around with this and has made
any proofs for any of these things, I would really like to know. It's been fun revisiting a part of my childhood and
exploring the nuances of this puzzle.

repository: cincospenguinos/GridAnalysis

repo_name: cincospenguinos/GridAnalysis


text:
1. SSH into server as root (if no user with superuser privileges exists)

2. Create an account with superuser privileges if not yet existing:
```bash
adduser cookietempleuser

usermod -aG sudo cookietempleuser

su cookietempleuser
```

3. Enable firewall
```bash
ufw allow OpenSSH
ufw enable
```

4. Clone the code and start the deployment script! Ensure beforehand that the user account and the URL are still matching!
```bash
cd ~

git clone https://github.com/mlf-core/mlf_core_website
```
```bash
sudo bash mlf_core_website/deployment_scripts/setup.sh
```


text:
![MediaMonks](https://user-images.githubusercontent.com/1291730/35807771-80335046-0a62-11e8-9723-17c69c25bc07.jpg)

## Challenge - Arrays 02

### a) Get The Months Between 2 Dates

Create a function that, given 2 dates, returns the names of the months that are present between them (inclusive).

**Tip:** you can read the tests to figure out how the return objects should look like.

### Instructions

``` bash
# install dependencies
npm install

# start the project
npm start
```

repository: alandawi/mmba-challenges

repo_name: alandawi/mmba-challenges


text:
JIT expr/expr~/fexpr~
===

Just-in-time (JIT) clones of the [expr/expr~/fexpr~](http://yadegari.org/expr/expr.html) [pure data](http://puredata.info/) objects.

Requirements
---

* [cmake](https://cmake.org/) 3.0 or greater
* [bison](https://www.gnu.org/software/bison/) tested with 3.0.4, didn't work with 2.3 on osX
* [flex](https://github.com/westes/flex) tested with 2.6.0
* [llvm](http://llvm.org/) 5.0
* [pure-data](https://puredata.info/) headers
* [pd.build](https://github.com/pierreguillot/pd.build)
	* it is already set up as a submodule, remember `git submodule init && git submodule update`

Build
---

### Linux

`./configure && make pd`

### osX

The build in flex header is old, I needed to target the one I installed with homebrew which was installed in */usr/local/opt/flex/include/*

* make the cmake build directory:
	* `mkdir build/ && cd build`
* let cmake know where your flex headers and m_pd.h are:
  * `cmake -DCMAKE_CXX_FLAGS="-I/usr/local/opt/flex/include/ -I/Applications/Pd-0.48-1.app/Contents/Resources/src/" ..`
  * with an older pd install it was:
    * `cmake -DCMAKE_CXX_FLAGS="-I/usr/local/opt/flex/include/ -I/Applications/Pd-0.48-0.app/Contents/Resources/include/" ..`

### Windows

Could use some help here..

Install
---

copy *build/jit_expr* to your appropriate *pd externals* directory

for example:

* Linux: `mkdir -p ~/.local/lib/pd/extra && cp -r build/jit_expr  ~/.local/lib/pd/extra/`
* MacOS: `cp -r build/jit_expr ~/Library/Pd/`
* Windows: not sure.. *%AppData%\Pd*

Notes
---

[godbolt](https://godbolt.org/) can be useful for finding what llvm instruction to use.
`-emit-llvm -S -O0`

Acknowledgements
---

* [Bison Flex C++ Template by Rémi Berson](https://github.com/remusao/Bison-Flex-CPP-template) was the starting point for the tokeniser and parser
* some of the LLVM code is based on the [llvm tutorial](https://llvm.org/docs/tutorial/)
* some of the expr pd code is based on the [original expr code](https://github.com/pure-data/pure-data) by [Shahrokh Yadegari](http://yadegari.org/) and [Miller Puckette](http://msp.ucsd.edu/software.html)

TODO
===

* remove overloaded virtual warning disable, if we can fix it
* convert more of the functions into LLVM code so it can be further optimized


text:
---
layout: default
title: TekyaHRX
nav_order: 2
has_children: false
permalink: /docs/signature/tekyahrx
nav_exclude: true
---

# TekyaHRX

## High-level Description

* Year: 2020
* Blog: https://www.trendmicro.com/en_us/research/20/f/new-tekya-ad-fraud-found-on-google-play.html

This malware attempts to steal information, perform ad-click fraud, and hide/change the app icon. Upon boot and developer-defined events, it checks the android version natively and a routine periodically checks whether a remote payload exists on the device. If it does not exist, the malware waits a set amount of time before downloading the remote payload. Once downloaded, the malware executes the remote payload to steal device/location information, hide/change the app icon, and perform ad-click fraud (all observed behaviors as the server was down at time of analysis).

## Signature
---

The image of the signature can be downloaded [here](../../img/signatures/TekyaHRX.png) for closer inspection.

![](../../img/signatures/TekyaHRX.png)


text:
# Laravel Simple Setup

A visual setup routine for Laravel's environment (.env) file. <br>
Change your environment variables as you like in a visual guided wizard and check your Database credentials live during setup wizard.

![Screenshot](https://user-images.githubusercontent.com/20622736/44989340-d1359780-af8d-11e8-80d5-9c2a8ff230ab.png)

## Features
- Simple Install Routine for beginner and experts
- Integrated Laravel Basic Auth System Switch (You can turn it on/off during setup)
- Generate new App Key on the fly
- Database Connection Live Testing
- Automatically create database if not exist (No matter if mysql, postgresql or sqlite)
- Disable Database
- Detailled Final Step Overview showing your changes to the env before you submit
- and more!

![Screenshot](https://user-images.githubusercontent.com/20622736/44989341-d1359780-af8d-11e8-9b0e-851759296f52.png)

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.
### Prerequisites

- Laravel 5.6 and up
- PHP >= 7.1.3
- PDO PHP Extension

### Installing

Require this package with composer. It is recommended to only require the package for development.

```shell
composer require rowo/laravel-simple-setup --dev
```
Laravel 5.6 uses Package Auto-Discovery, so doesn't require you to manually add the ServiceProvider.

## Start Setup

Start your Laravel server with

```shell
php artisan serve
```

and go to /setup

## Authors

* **Kevin Rodd** - *Initial work* - [Kevin Rodd](https://github.com/kevinrodd)
* **Andreas Wolf** - *Initial work* - [AWolf86](https://github.com/Kappalores)

## License

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

repository: kevinrodd/laravel-simple-setup

repo_name: kevinrodd/laravel-simple-setup


text:
# Releasing a new version

This guide aims to provide guidance on how to release new versions of the `apm-agent-dotnet` binary as well as updating all the necessary parts to make it successful.

## Prerequisites

Releasing a new version of the binary implies that there have been changes in the source code which are meant to be released for wider consumption. Before releasing a new version there's some prerequisites that have to be checked.

### Make sure the version is updated

Since the source has changed, we need to update the current committed version to a higher version so that the release is published.

The version is currently defined in the [Directory.Build.props](./src/Directory.Build.props) in the [SEMVER](https://semver.org) format: `MAJOR.MINOR.BUG`

Say we want to perform a minor version release (i.e. no breaking changes and only new features and bug fixes are being included); in which case we'll update the _MINOR_ part of the version.

For instance, the bump from version 1.1.2 to 1.2 can be found in this https://github.com/elastic/apm-agent-dotnet/pull/624

### Generating a changelog for the new version

Once the version is updated, we can then generate the changelog, you can see the current changelog in [`CHANGELOG.asciidoc`](CHANGELOG.asciidoc). The idea is to fill all the applicable sections so that users can consume an orderly changelog.

For major and minor releases, you'll also need to update the EOL table in [`upgrading.asciidoc`](docs/upgrading.asciidoc). The EOL date is the release date plus 18 months.

After a changelog has been manually curated, a new pull request can be opened with the changelog and version update changes (and EOL table if applicable).

For instance, the changelog that was created for the 1.2 release can be found in this https://github.com/elastic/apm-agent-dotnet/pull/640

## Releasing a new package

In case you release a package the first time and you rely on the CI to push that to nuget.org, you need to make sure that the [deploy.sh](https://github.com/elastic/apm-agent-dotnet/blob/master/.ci/linux/deploy.sh) script is updated. You need to add the name of the new package into that script.

## Executing the release

After the new changelog and version have been merged to master, the only thing remaining is to run the below commands:

 ```bash
 ## let's assume the origin is your forked repo and upstream the one where the releases are coming from.
 git checkout master

 ## let's ensure we do use the latest commit, although this requirement could be not neccessary if it's required
 ## to use another git commit rather than the HEAD at that time.
 git reset --hard upstream/master

 ## <major>, <minor>, <bug> and <suffix> should be replaced accordingly. <suffix> is an optional one.
 git tag <major>.<minor>.<bug>(-<suffix>)?

 ## Push commit to the usptream repo.
 git push upstream <major>.<minor>.<bug>(-<suffix>)?
 ```

The above commands will push the GitHub tag and will trigger the corresponding [CI Build pipeline](Jenkinsfile) which will run all the required stages to satisfy the release is in a good shape, then at the very end of the pipeline there will be an input approval waiting for an UI interaction to release to the NuGet repo. This particular input approval step will notify by email, to the owners of this repo, regarding the expected action to be done for doing the release.

This release process is a tagged release event based with an input approval.

## Executing the release script locally

If required then it's possible to run the release script locally, for such, the credentials are needed to push to the NuGet repo.

```bash
.ci/linux/release.sh
.ci/linux/deploy.sh <API_KEY> <SERVER_URL>
```

_NOTE_ The above scripts are just wrapper for the `dotnet` command.


text:
# Bootstrap Portfolio

**Welcome!**

This will be temporary landing portfolio page until I am ready to export the content elsewhere. Take a moment to visit the [live page](https://arinmsn.github.io/Portfolio-Page/) to learn more about me.

The blog link is not active yet.

## Copyright and License

Copyright 2013-2019 Blackrock Digital LLC. Code released under the [MIT](https://github.com/BlackrockDigital/startbootstrap-stylish-portfolio/blob/gh-pages/LICENSE) license.

repository: arinmsn/Portfolio-Page

gha_language: CSS

repo_name: arinmsn/Portfolio-Page


text:
---
title: Reviewing Contributions
---

This page details how to review contributions submitted for Apache Jena, it is intended primarily for Jena committers but is also useful in helping contributors understand what we expect from a contribution.

# Patch Guidelines

When reviewing contributed patches to Jena the committers are going to be considered the following:

 1. Does the pull request includes tests?
 1. Does the pull request includes documentation?
 1. Does it have Apache copyright headers?
 1. Are there any @author tags?
 1. Is it contributed to Apache?
 1. What is the size and impact on Jena of the contribution?
 1. Is IP clearance required?
 1. Pull requests and commit messages

## Including Tests

Including tests is almost always a must for a patch unless the patch is for non-code
content e.g. CMS diffs, maven config tweaks.

Tests are **essential** for bug fixes but should be considered mandatory for any patch.  Jena uses JUnit for tests and uses the standard Java *src/test/* directory conventions within its modules.

## Including Documentation

Users will not find or understand new feature if there is no documentation.

## Apache Copyright Headers

Code for inclusion in Jena should contain Apache copyright headers, **only**
the contributor should remove/change copyright headers so if a different copyright
header is present then you **must** request that the contributor change the
copyright headers.

## No @author Tags

The Jena PMC have agreed not to maintain @author tags in the code since generally
authorship can be identified from the SVN history anyway and over time
committers will typically touch much code even if only briefly and in minor ways.

@author tags will not prevent a contribution being accepted but **should**
be removed by the committer who integrates the contribution.

## Code style

Jena does not have a particular formal code style specification, but here are some simple tips for keeping your contribution in good order:

- Jena uses the Java code conventions with spaces (not tabs!), an indent of 4, and opening braces on the same line. Use no trailing whitespace if avoidable. Use common sense to make your code readable for the next person.
- Don't create a method signature that throws checked exceptions that aren't ever actually thrown from the code in that method unless an API supertype specifies that signature. Otherwise, clients of your code will have to include unnecessary handling code.
- Don't leave unused imports in your code. IDEs provide facilities to clean imports.
- If a type declares a supertype that isn't a required declaration, consider whether that clarifies or confuses the intent.
- Minimize the new compiler warnings your patch creates. If you use @SuppressWarnings to hide them, please add a comment explaining the situation.
- Remove unused local variables or fields.
- If there is valuable code in some unused private method, add a @SuppressWarnings("unused") with an explanation of when it might become useful.

## Contribution to Apache

The Apache License states that any contribution to an Apache project is automatically considered
to be contributed to the Apache foundation and thus liable for inclusion in an Apache project.

Generally you will not have to worry about this but if anyone ever states that code is not
for inclusion then we **must** abide by that or request that they make a statement
that they are contributing the code to Apache.

## Size and Impact on Jena

Small patches can generally be incorporated immediately, larger patches - particularly those adding significant
features - should usually be discussed on the [dev<EMAIL_ADDRESS>list prior to acceptance.

Use your judgement here, a few hundred lines of code may be considered small if it isn't changing/extending functionality significantly.
Conversely a small patch that changes a core behavior should be more widely discussed.

If in doubt start a thread on dev or comment on the JIRA issue, JIRA comments get copied to the dev list
so all developers should see the comments even if they aren't explicitly watching the issue.

## IP Clearance

Depending on where a patch comes from there may be IP clearance issues, for small patches this is generally a non-issue.
Where this comes into play is when a large patch is coming in which has been developed completely externally to Jena, particularly if that patch has been developed for/on behalf of a company rather than be developers working in their free time.

For patches like this we may require that the company in question submit a [CCLA](https://www.apache.org/licenses/cla-corporate.txt) and that the developers involve submit [ICLAs](https://www.apache.org/licenses/icla.pdf).  There may also need to be IP Clearance vote called on the developer list to give developers a chance to review the code and check that there isn't anything being incorporated that violates Apache policy.

## Pull Requests and Commit Messages

A pull request is a single unit so a large number of commits details the evolution internally
but does not help record the external contribution.

Consider asking the contributor to merge commits into a few with useful messages for an external reviewer.

## Project Processes

[Project Processes](https://cwiki.apache.org/confluence/display/JENA/Processes) including:

* [Release process](https://cwiki.apache.org/confluence/display/JENA/Release+Process)
* [Commit Workflow for Github-ASF](https://cwiki.apache.org/confluence/display/JENA/Commit+Workflow+for+Github-ASF)

repository: apache/jena-site

gha_language: HTML

repo_name: apache/jena-site