webhook2status: an awesome and simple request generator to change Slack status via webhook, IFTTT and curl. / View on GitHub
This tool issues following permission scopes:
user.profile:write
Go to the Slack App manage page and revoke webhook2status.
This service does not store ANY sensitive data including your persistent OAuth token, password or access log.


Load frame in top window
CSV Text:
a,b,c c1v,"a string with ""quotes"", and a comma",colum3value
CSV Text - - > Editor
Editor - - > CSV Text
Editor:
Row Operations:
insert before
insert after
delete
Column Operations:
insert before
insert after
delete


Demos:
Quick tour of Polymer
Registration and lifecycle
Declared properties
Local DOM
Events
Data binding


C syntax:
int phish_query(char *keyword, int flag1, int flag2) void phish_set(char *keyword, int flag1, int flag2)
idlocal flag1,flag2 = ignored nlocal flag1,flag2 = ignored idglobal flag1,flag2 = ignored nglobal flag1,flag2 = ignored inport/status flag1 = input port # (0 to Maxport-1) flag2 = ignored inport/nconnect flag1 = input port # (0 to Maxport-1) flag2 = ignored inport/nminnow flag1 = input port # (0 to Maxport-1) flag2 = connection # on that port (0 to Nconnect-1) outport/status flag1 = output port # (0 to Maxport-1) flag2 = ignored outport/nconnect flag1 = output port # (0 to Maxport-1) flag2 = ignored outport/nminnow flag1 = output port # (0 to Maxport-1) flag2 = connection # on that port (0 to Nconnect-1) outport/direct flag1 = output port # (0 to Maxport-1) flag2 = ignored
ring/receiver flag1 = input port # (0 to Maxport-1) flag2 = receiver ID (0 to Nring-1)
C examples:
#include "phish.h" int nlocal = phish_query("nlocal",0,0); int nrecv = phish_query("outport/direct",2,0); phish_set("ring/receiver",0,3);
C++ syntax:
int query(char *keyword, int flag1, int flag2) void set(char *keyword, int flag1, int flag2)
C++ examples:
#include "phish.hpp" int nlocal = phish::query("nlocal",0,0); int nrecv = phish::query("outport/direct",2,0); phish::set("ring/receiver",0,3);
Python syntax:
def query(str,flag1,flag2) def set(str,flag1,flag2)
Python examples:
import phish nlocal = phish.query("nlocal",0,0) nrecv = phish.query("outport/direct",2,0) phish.set("ring/receiver",0,3)
Description:
These are PHISH library functions which can be called from a minnow application. In PHISH lingo, a "minnow" is a stand-alone application which makes calls to the PHISH library.
These functions are used to query and reset information stored internally in PHISH. New keywords may be added as usage cases arise.
For phish_query, the "idlocal", "nlocal", "idglobal", and "nglobal" keywords return info about the minnow and its relation to other minnows running the PHISH program. These keywords ignore the flag1 and flag2 values; they can simply be set to 0.
A PHISH program typically includes one or more sets of minnows, as specified in a PHISH input script. Each minnow in each set is an individual process. In a local sense, each minnow has a local-ID from 0 to Nlocal-1 within its set, where Nlocal is the number of minnows in the set. Globally, each minnow has a global-ID from 0 to Nglobal-1, where Nglobal is the total number of minnows. The global-IDs are ordered by set, so that minnows within each set have consecutive IDs. These IDs enable the PHISH library to orchestrate communication of datums between minnows in different sets. E.g. when running the MPI version of the PHISH library, the global-ID corresponsds to the rank ID of an MPI process, used in MPI_Send() and MPI_Recv() function calls.
For phish_query, the "inport/status", "inport/nconnect", and "inport/nminnows" keywords return info about the input ports that connect to the minnow by which it receives datums from other minnows. Likewise, the "outport/status", "outport/nconnect", "output/nminnows", and "output/direct" keywords return info about the output ports the minnow connects to by which it sends datums to other minnows.
All of these keywords require the use of flag1 to specify the input or output port, which is a number from 0 to Maxport-1. Some of them, as noted below, require the use of flag2 to specify the connection #, which is a number from 0 to Nconnect-1.
See this section of the PHISH Minnows doc page for more information about input and output ports.
See the hook command which is processed by the bait.py tool in a PHISH input script, to establish connections between sets of minnows.
The "status" keyword returns the status of the port, which is one of the following values:
The "nconnect" keyword returns the number of sets of minnows that are connected to a port.
The "nminnows" keyword returns the number of minnows connected to a port thru a specific connection, as specified by flag2.
The "outport/direct" keyword returns the number of minnows connected to an output port thru a connection of style direct. The first such connection found is used to return this value, so if another direct connection is desired, the "outport/nminnows" keyword should be used.
See the phish_send_direct function for a discussion of how datums are sent via direct style connections, and why this particular phish_query() keyword can be useful.
For phish_set, the "ring/receiver" keyword changes the minnow that this minnow sends messages to. This keyword can only be used when the minnow is part of school of minnows that is exchanging datums via a "ring" connection; see the hook command in PHISH input scripts that defines the ring connection. This keyword can be used to effectively permute the ordering of the minnows in the ring.
For ring/receiver, flag1 is the output port number. Flag2 is the new receiving minnow to send datums to on that port. It should be a value from 0 to Nring-1 inclusive, where Nring = the # of minnows in the ring.
Restrictions: none
Related commands:


Nick:
I was working on a subset of MySQL procedures and PHP along the way. It really put the SQL class I was taking into a practical setting, and I got to understand the PDO custom queries, session objects. I also got to watch Alex make the front end visually appealing with the libraries he was using, and Joe code everything with vim from his linux shell. It was fun.
Alexander McNulty:Not much is know about this CSS wizard.Joe:
As my first free-lance gig I pitched a website idea to the owners of the company I work for. I knew it was beyond my experience so I undertook this project to prepare. I had experience in all required domains - html, client/server communication, ajax, connecting a program to a database and hosting an application on a server - however I'd yet to combine it all into a complete program. I was feeling adventurous and decided to write the game's logic in MySQL stored procedures.  The switch only took a day (until 7 AM) thanks to the game logic already existing in the database - all I had to do was rewrite my procedure calls in Javascript.
Prior to this project I always wondered why companies keep programmers employed after their main product is released; now I know. There's a deceptively large amount of work to do behind even a simple program like this one. As soon as I finished one feature, ideas for many more would appear. I had loftier plans for this project before Alex, with his experience and practical thinking, encouraged me to think in terms of a minimum viable product. One quarter later and we barely made it to the MVP! Next time around I'd like to enable https, configure nginx to properly port forward for enhanced security, get email verification working for user registration, enable password recovery and many more features.
I learned an incredible amount from this project and am thankful for my group members Alex and Nick, as well as the advice I recieved from the Developer's Guild officers Anthony, Chris and Paul, and finally the Developer's Guild club for giving me the opportunity to propose, lead, and see this project to fruition.
Instructions
The game is simple: be top-doge.
Buy attackers and attack other rows; when a row's morale hits 0 it's destroyed.
Attackers cost money; more money generators accrue money faster, and likewise for fuel and fuel generators.
The "source" input is either the row which is paying for a purchase, sending resources and troops, or making an attack.
The "target" input is either the row which to be purchased, accept a transfer, or be attacked.
An attack is strengthened by a row's attacker level.
A row's defense is strengthened by its defense level.
Attackers defend their row, so buy many!
Wounded attackers recover from the hospital at a rate which can be increased by increasing a row's hospital level.


Custom Digital Solutions for Business
Custom design, development and marketing solutions for the digital era.
Recent Projects
Gigi's Crafty Place
We had great fun working on this website for the Cohasset based party venue, Gigi's Crafty Place.
Van Etten Consulting
Van Etten Consulting, based in Cohasset, needed a new logo and website re-design.
Silk+Teak
This Milton based eCommerce startup, needed a custom website and digital marketing strategy.
Contact Us
Give us a call
We're excited to hear about your project!


Select your town
See what do politicians with
When you are okay (or not) with that, click on the button
Please note that actual data are related to France 2011 budget. See "About" page for details
Tell politicians what you would like they do with
Change the budget allocation according to your Democratic spirit.
Use buttons on top of the bars and when you are done click on the button to save your changes
See what others have suggest to politicians
This show (in average) how people would have manage the budget.
Click here to share this with your friends !


--- layout: post title: An Afternoon at St Erth date: 2011-10-03 08:41:46.000000000 -04:00 categories: - Favourite Places - Recommendations - Seasons tags: - Blackwood - Day trips from Melbourne - Gardening - Gardening with children - Spring - St Erth - The Digger's Club - Things to do with children status: publish type: post published: true meta: aktt_notify_twitter: 'no' _edit_last: '1' dsq_thread_id: '1188595029' author: login: cint email<EMAIL_ADDRESS>display_name: Jacinta first_name: Jacinta last_name: '' ---
We ventured to St Erth in Blackwood the other day to pick up the girls from my mum who had the girls in Ballarat for a sleepover. It was a perfect spring day with gorgeous blue skies and the sun offered a little warmth, when not in the shade. We had a lovely picnic amongst the gumtrees and the daffodils.
After the picnic, the girls and I had a fun time in the shop picking out seeds for our veggie patch. They stock mostly heirloom varieties and organic where possible, which makes for a fun selection.
[caption id="attachment_1207" align="aligncenter" width="600" caption="The daffodils were blooming en masse"][/caption]
I stood back at one stage and commented to Greg that Scarlett and Tenneille were so excited about choosing which seeds they wanted, it was comparable to the excitement of choosing lollies in a lolly shop! I only wish I had taken video of it. They got to pick a couple of seed packs each which they will get to plant themselves and, well I chose, LOTS! When Tenneille took her seeds up to the counter to be paid for, she commented to the lady serving us, "I'm going to raise the seeds as my own child". It was so funny. The things she comes out with!
After our seed buying frenzy, the girls and I wondered around the beautiful gardens. Scarlett spent most of the time giving Tenneille pony rides and they had fun checking out where all the garden paths lead.
[caption id="attachment_1205" align="aligncenter" width="600" caption="St Erth"][/caption]
[caption id="attachment_1206" align="aligncenter" width="416" caption="Looking out the front door of St Erth"][/caption]
[caption id="attachment_1208" align="aligncenter" width="451" caption="Just one of the views from the many garden paths"][/caption]
I'm hoping we have a wonderful bounty to show you once summer and autumn arrive. I just need to have words with those rascally snails that seem to think anything I plant is food just for them!
[caption id="attachment_1210" align="aligncenter" width="600" caption="The bounty!"][/caption]
So if you ever find yourself in Blackwood, make sure you check out St Erth. St Erth is part of The Digger's Club and I can promise you if you love gardening, you won't be able to leave empty handed.
[caption id="attachment_1209" align="aligncenter" width="600" caption="Blossoms on one of the espalier fruit trees"][/caption]
Jacinta x


Testing with DevStack¶
This document describes how to test OpenStack with OVN using DevStack. We will start by describing how to test on a single host.
Single Node Test Environment¶
- Create a test system.
It’s best to use a throwaway dev system for running DevStack. In this example I’m using a Fedora 21 VM with 4 GB of RAM. You should be able to use any distribution that is supported by DevStack. So far, networking-ovn is being tested on Fedora 21 and Ubuntu 14.04.
Create a user and grant it sudo access. Install git.
- Get DevStack and networking-ovn.
$ git clone http://git.openstack.org/openstack-dev/devstack.git
$ git clone http://git.openstack.org/openstack/networking-ovn.git
- Configure DevStack to use networking-ovn.
networking-ovn comes with a sample DevStack configuration file you can start with. For example, you may want to set some values for the various PASSWORD variables in that file so DevStack doesn’t have to prompt you for them. Feel free to edit it if you’d like, but it should work as-is.
$ cd devstack
$ cp ../networking-ovn/devstack/local.conf.sample local.conf
- Run DevStack.
This is going to take a while. It installs a bunch of packages, clones a bunch of git repos, and installs everything from these git repos.
$ ./stack.sh
Once DevStack completes successfully, you should see output that looks something like this:
This is your host ip: <IP_ADDRESS>
Horizon is now available at http://<IP_ADDRESS>/
Keystone is serving at http://<IP_ADDRESS>:5000/
The default users are: admin and demo
The password: password
2015-04-30 22:02:40.220 | stack.sh completed in 515 seconds.
Environment Variables¶
Once DevStack finishes successfully, we’re ready to start interacting with OpenStack APIs. OpenStack provides a set of command line tools for interacting with these APIs. DevStack provides a file you can source to set up the right environment variables to make the OpenStack command line tools work.
$ . openrc
If you’re curious what environment variables are set, they generally start with an OS prefix:
$ env | grep OS
OS_REGION_NAME=RegionOne
OS_IDENTITY_API_VERSION=2.0
OS_PASSWORD=password
OS_AUTH_URL=http://<IP_ADDRESS>:5000/v2.0
OS_USERNAME=demo
OS_TENANT_NAME=demo
OS_VOLUME_API_VERSION=2
OS_CACERT=/opt/stack/data/CA/int-ca/ca-chain.pem
OS_NO_CACHE=1
Default Network Configuration¶
By default, DevStack creates a network called private
. Run the following
command to see the existing networks:
$ neutron net-list
+--------------------------------------+---------+----------------------------------------------------------+
| id | name | subnets |
+--------------------------------------+---------+----------------------------------------------------------+
| 266371ca-904e-4433-b653-866f9204d22e | private | 64bc14c2-52a6-4188-aaeb-d24922125c2c fde5:95da:6b50::/64 |
| | | 299d182b-2f2c-44e2-9bc9-d094b9ea317b <IP_ADDRESS>/24 |
+--------------------------------------+---------+----------------------------------------------------------+
A Neutron network is implemented as an OVN logical switch. networking-ovn
creates logical switches with a name in the format neutron-<network UUID>. So,
we can use ovn-nbctl
to list the configured logical switches and see that
their names correlate with the output from neutron net-list
:
$ ovn-nbctl ls-list
c628c46a-372f-412b-8edf-eb3408b021ca (neutron-266371ca-904e-4433-b653-866f9204d22e)
$ ovn-nbctl get Logical_Switch neutron-266371ca-904e-4433-b653-866f9204d22e external_ids
{"neutron:network_name"=private}
There will be one port created automatically when not using OVN native DHCP.
This port corresponds to the Neutron DHCP agent that is providing DHCP services
to the private
network.
$ neutron port-list
+--------------------------------------+------+-------------------+-------------------------------------------------------------------------------------------------------------+
| id | name | mac_address | fixed_ips |
+--------------------------------------+------+-------------------+-------------------------------------------------------------------------------------------------------------+
| 51f98e51-143b-4968-a7a9-e2d8d419b246 | | fa:16:3e:6e:63:b1 | {"subnet_id": "299d182b-2f2c-44e2-9bc9-d094b9ea317b", "ip_address": "<IP_ADDRESS>"} |
| | | | {"subnet_id": "64bc14c2-52a6-4188-aaeb-d24922125c2c", "ip_address": "fde5:95da:6b50:0:f816:3eff:fe6e:63b1"} |
+--------------------------------------+------+-------------------+-------------------------------------------------------------------------------------------------------------+
One can determine the DHCP port by running:
neutron port-list --device-owner 'network:dhcp'
This will return the DHCP port that was created by Neutron.
The owner of the port, that is, the ‘device_owner’, will have details of the port owner. For example the port owned by a Nova instance will have device_owner ‘compute:None’ when availability zone is not set.
Booting VMs¶
In this section we’ll go through the steps to create two VMs that have a
virtual NIC attached to the private
Neutron network.
DevStack uses libvirt as the Nova backend by default. If KVM is available, it will be used. Otherwise, it will just run qemu emulated guests. This is perfectly fine for our testing, as we only need these VMs to be able to send and receive a small amount of traffic so performance is not very important.
- Get the Network UUID.
Start by getting the UUID for the private
network from the output of
neutron net-list
from earlier and save it off:
$ PRIVATE_NET_ID=266371ca-904e-4433-b653-866f9204d22e
- Create an SSH keypair.
Next create an SSH keypair in Nova. Later, when we boot a VM, we’ll ask that the public key be put in the VM so we can SSH into it.
$ nova keypair-add demo > id_rsa_demo
$ chmod 600 id_rsa_demo
- Choose a flavor.
We need minimal resources for these test VMs, so the m1.nano
flavor is
sufficient.
$ nova flavor-list
+----+-----------+-----------+------+-----------+------+-------+-------------+-----------+
| ID | Name | Memory_MB | Disk | Ephemeral | Swap | VCPUs | RXTX_Factor | Is_Public |
+----+-----------+-----------+------+-----------+------+-------+-------------+-----------+
| 1 | m1.tiny | 512 | 1 | 0 | | 1 | 1.0 | True |
| 2 | m1.small | 2048 | 20 | 0 | | 1 | 1.0 | True |
| 3 | m1.medium | 4096 | 40 | 0 | | 2 | 1.0 | True |
| 4 | m1.large | 8192 | 80 | 0 | | 4 | 1.0 | True |
| 42 | m1.nano | 64 | 0 | 0 | | 1 | 1.0 | True |
| 5 | m1.xlarge | 16384 | 160 | 0 | | 8 | 1.0 | True |
| 84 | m1.micro | 128 | 0 | 0 | | 1 | 1.0 | True |
+----+-----------+-----------+------+-----------+------+-------+-------------+-----------+
$ FLAVOR_ID=42
- Choose an image.
DevStack imports the CirrOS image by default, which is perfect for our testing. It’s a very small test image.
$ glance image-list
+--------------------------------------+---------------------------------+
| ID | Name |
+--------------------------------------+---------------------------------+
| 990e80d3-5260-40c4-8ece-e5a428e1b6d7 | cirros-0.3.4-x86_64-uec |
| 1a76e6c3-857a-4975-bdff-1ebe6f3ce193 | cirros-0.3.4-x86_64-uec-kernel |
| 11fa05eb-c88a-4de7-b2f7-1da203eafc9c | cirros-0.3.4-x86_64-uec-ramdisk |
+--------------------------------------+---------------------------------+
$ IMAGE_ID=990e80d3-5260-40c4-8ece-e5a428e1b6d7
- Setup a security rule so that we can access the VMs we will boot up next.
By default, DevStack does not allow users to access VMs, to enable that, we will need to add a rule. We will allow both ICMP and SSH.
$ neutron security-group-rule-create --direction ingress --ethertype IPv4 --port-range-min 22 --port-range-max 22 --protocol tcp default
$ neutron security-group-rule-create --direction ingress --ethertype IPv4 --protocol ICMP default
$ neutron security-group-rule-list
+--------------------------------------+----------------+-----------+-----------+---------------+-----------------+
| id | security_group | direction | ethertype | protocol/port | remote |
+--------------------------------------+----------------+-----------+-----------+---------------+-----------------+
| 8b2edbe6-790e-40ef-af54-c7b64ced8240 | default | ingress | IPv4 | 22/tcp | any |
| 5bee0179-807b-41d7-ab16-6de6ac051335 | default | ingress | IPv4 | icmp | any |
...
+--------------------------------------+----------------+-----------+-----------+---------------+-----------------+
- Boot some VMs.
Now we will boot two VMs. We’ll name them test1
and test2
.
$ nova boot --nic net-id=$PRIVATE_NET_ID --flavor $FLAVOR_ID --image $IMAGE_ID --key-name demo test1
+--------------------------------------+----------------------------------------------------------------+
| Property | Value |
+--------------------------------------+----------------------------------------------------------------+
| OS-DCF:diskConfig | MANUAL |
| OS-EXT-AZ:availability_zone | nova |
| OS-EXT-STS:power_state | 0 |
| OS-EXT-STS:task_state | scheduling |
| OS-EXT-STS:vm_state | building |
| OS-SRV-USG:launched_at | - |
| OS-SRV-USG:terminated_at | - |
| accessIPv4 | |
| accessIPv6 | |
| adminPass | aQJMqi8vAWJP |
| config_drive | |
| created | 2015-05-01T01:55:27Z |
| flavor | m1.nano (42) |
| hostId | |
| id | 571f622e-8f65-4617-9b39-6a04438f394f |
| image | cirros-0.3.4-x86_64-uec (990e80d3-5260-40c4-8ece-e5a428e1b6d7) |
| key_name | demo |
| metadata | {} |
| name | test1 |
| os-extended-volumes:volumes_attached | [] |
| progress | 0 |
| security_groups | default |
| status | BUILD |
| tenant_id | c41f413079aa4389b7a41932cd8a6be6 |
| updated | 2015-05-01T01:55:27Z |
| user_id | 98978389ceb3433cb1db3f64da217ee0 |
+--------------------------------------+----------------------------------------------------------------+
$ nova boot --nic net-id=$PRIVATE_NET_ID --flavor $FLAVOR_ID --image $IMAGE_ID --key-name demo test2
+--------------------------------------+----------------------------------------------------------------+
| Property | Value |
+--------------------------------------+----------------------------------------------------------------+
| OS-DCF:diskConfig | MANUAL |
| OS-EXT-AZ:availability_zone | nova |
| OS-EXT-STS:power_state | 0 |
| OS-EXT-STS:task_state | scheduling |
| OS-EXT-STS:vm_state | building |
| OS-SRV-USG:launched_at | - |
| OS-SRV-USG:terminated_at | - |
| accessIPv4 | |
| accessIPv6 | |
| adminPass | HxAQk8pSi53d |
| config_drive | |
| created | 2015-05-01T01:55:33Z |
| flavor | m1.nano (42) |
| hostId | |
| id | 7a8c12da-54b3-4adf-bba5-74df9fd2e907 |
| image | cirros-0.3.4-x86_64-uec (990e80d3-5260-40c4-8ece-e5a428e1b6d7) |
| key_name | demo |
| metadata | {} |
| name | test2 |
| os-extended-volumes:volumes_attached | [] |
| progress | 0 |
| security_groups | default |
| status | BUILD |
| tenant_id | c41f413079aa4389b7a41932cd8a6be6 |
| updated | 2015-05-01T01:55:33Z |
| user_id | 98978389ceb3433cb1db3f64da217ee0 |
+--------------------------------------+----------------------------------------------------------------+
Once both VMs have been started, they will have a status of ACTIVE
:
$ nova list
+--------------------------------------+-------+--------+------------+-------------+--------------------------------------------------------+
| ID | Name | Status | Task State | Power State | Networks |
+--------------------------------------+-------+--------+------------+-------------+--------------------------------------------------------+
| 571f622e-8f65-4617-9b39-6a04438f394f | test1 | ACTIVE | - | Running | private=fde5:95da:6b50:0:f816:3eff:fe92:579a, <IP_ADDRESS> |
| 7a8c12da-54b3-4adf-bba5-74df9fd2e907 | test2 | ACTIVE | - | Running | private=fde5:95da:6b50:0:f816:3eff:fe42:cbc7, <IP_ADDRESS> |
+--------------------------------------+-------+--------+------------+-------------+--------------------------------------------------------+
Our two VMs have addresses of <IP_ADDRESS>
and <IP_ADDRESS>
. If we list
Neutron ports again, there are two new ports with these addresses associated
with the:
$ neutron port-list
+--------------------------------------+------+-------------------+-------------------------------------------------------------------------------------------------------------+
| id | name | mac_address | fixed_ips |
+--------------------------------------+------+-------------------+-------------------------------------------------------------------------------------------------------------+
| 51f98e51-143b-4968-a7a9-e2d8d419b246 | | fa:16:3e:6e:63:b1 | {"subnet_id": "299d182b-2f2c-44e2-9bc9-d094b9ea317b", "ip_address": "<IP_ADDRESS>"} |
| | | | {"subnet_id": "64bc14c2-52a6-4188-aaeb-d24922125c2c", "ip_address": "fde5:95da:6b50:0:f816:3eff:fe6e:63b1"} |
| d660a917-5095-4bd0-92c5-d0abdffb600b | | fa:16:3e:42:cb:c7 | {"subnet_id": "299d182b-2f2c-44e2-9bc9-d094b9ea317b", "ip_address": "<IP_ADDRESS>"} |
| | | | {"subnet_id": "64bc14c2-52a6-4188-aaeb-d24922125c2c", "ip_address": "fde5:95da:6b50:0:f816:3eff:fe42:cbc7"} |
| e3800c90-24d4-49ad-abb2-041a2e3dd259 | | fa:16:3e:92:57:9a | {"subnet_id": "299d182b-2f2c-44e2-9bc9-d094b9ea317b", "ip_address": "<IP_ADDRESS>"} |
| | | | {"subnet_id": "64bc14c2-52a6-4188-aaeb-d24922125c2c", "ip_address": "fde5:95da:6b50:0:f816:3eff:fe92:579a"} |
+--------------------------------------+------+-------------------+-------------------------------------------------------------------------------------------------------------+
$ TEST1_PORT_ID=e3800c90-24d4-49ad-abb2-041a2e3dd259
$ TEST2_PORT_ID=d660a917-5095-4bd0-92c5-d0abdffb600b
Now we can look at OVN using ovn-nbctl
to see the logical switch ports
that were created for these two Neutron ports. The first part of the output
is the OVN logical switch port UUID. The second part in parentheses is the
logical switch port name. Neutron sets the logical switch port name equal to
the Neutron port ID.
$ ovn-nbctl lsp-list neutron-$PRIVATE_NET_ID
1117ac4e-1c83-4fd5-bb16-6c9c11150446 (e3800c90-24d4-49ad-abb2-041a2e3dd259)
9be0ab27-1565-4b92-b2d2-c4578e90c46d (d660a917-5095-4bd0-92c5-d0abdffb600b)
1e81abcf-574b-4533-8202-da182491724c (51f98e51-143b-4968-a7a9-e2d8d419b246)
These three ports correspond to the DHCP agent plus the two VMs we created.
Adding Another Compute Node¶
After completing the earlier instructions for setting up devstack, you can use a second VM to emulate an additional compute node. This is important for OVN testing as it exercises the tunnels created by OVN between the hypervisors.
Just as before, create a throwaway VM but make sure that this VM has a different host name. Having same host name for both VMs will confuse Nova and will not produce two hypervisors when you query nova hypervisor list later. Once the VM is setup, create a user with sudo access and install git.
$ git clone http://git.openstack.org/openstack-dev/devstack.git
$ git clone http://git.openstack.org/openstack/networking-ovn.git
networking-ovn comes with another sample configuration file that can be used for this:
$ cd devstack
$ cp ../networking-ovn/devstack/computenode-local.conf.sample local.conf
You must set SERVICE_HOST in local.conf. The value should be the IP address of the main DevStack host. You must also set HOST_IP to the IP address of this new host. See the text in the sample configuration file for more information. Once that is complete, run DevStack:
$ cd devstack
$ ./stack.sh
This should complete in less time than before, as it’s only running a single OpenStack service (nova-compute) along with OVN (ovn-controller, ovs-vswitchd, ovsdb-server). The final output will look something like this:
This is your host ip: <IP_ADDRESS>
2015-05-09 01:21:49.565 | stack.sh completed in 308 seconds.
Now go back to your main DevStack host. You can use admin credentials to verify that the additional hypervisor has been added to the deployment:
$ cd devstack
$ . openrc admin
$ nova hypervisor-list
+----+------------------------------------+-------+---------+
| ID | Hypervisor hostname | State | Status |
+----+------------------------------------+-------+---------+
| 1 | ovn-devstack-1 | up | enabled |
| 2 | ovn-devstack-2 | up | enabled |
+----+------------------------------------+-------+---------+
You can also look at OVN and OVS to see that the second host has shown up. For
example, there will be a second entry in the Chassis table of the
OVN_Southbound database. You can use the ovn-sbctl
utility to list
chassis, their configuration, and the ports bound to each of them:
$ ovn-sbctl show
Chassis "9f844100-bf55-445a-8107-8f1cba584ac5"
Encap geneve
ip: "<IP_ADDRESS>"
Port_Binding "e3800c90-24d4-49ad-abb2-041a2e3dd259"
Port_Binding "d660a917-5095-4bd0-92c5-d0abdffb600b"
Port_Binding "51f98e51-143b-4968-a7a9-e2d8d419b246"
Chassis "52fd2e32-f9ca-4abd-a8e4-fdf1842079d2"
Encap geneve
ip: "<IP_ADDRESS>"
You can also see a tunnel created to the other compute node:
$ ovs-vsctl show
...
Bridge br-int
fail_mode: secure
Port "ovn-90b4d4-0"
Interface "ovn-90b4d4-0"
type: geneve
options: {key=flow, remote_ip="<IP_ADDRESS>"}
...
Provider Networks¶
Neutron has a “provider networks” API extension that lets you specify some additional attributes on a network. These attributes let you map a Neutron network to a physical network in your environment. The OVN ML2 driver is adding support for this API extension. It currently supports “flat” and “vlan” networks.
Here is how you can test it:
First you must create an OVS bridge that provides connectivity to the provider network on every host running ovn-controller. For trivial testing this could just be a dummy bridge. In a real environment, you would want to add a local network interface to the bridge, as well.
$ ovs-vsctl add-br br-provider
ovn-controller on each host must be configured with a mapping between a network name and the bridge that provides connectivity to that network. In this case we’ll create a mapping from the network name “providernet” to the bridge ‘br-provider”.
$ ovs-vsctl set open . \
external-ids:ovn-bridge-mappings=providernet:br-provider
Now create a Neutron provider network.
$ neutron net-create provider --shared \
--provider:physical_network providernet \
--provider:network_type flat
Alternatively, you can define connectivity to a VLAN instead of a flat network:
$ neutron net-create provider-101 --shared \
--provider:physical_network providernet \
--provider:network_type vlan \
--provider:segmentation_id 101
Observe that the OVN ML2 driver created a special logical switch port of type localnet on the logical switch to model the connection to the physical network.
$ ovn-nbctl show
...
switch 5bbccbbd-f5ca-411b-bad9-01095d6f1316 (neutron-729dbbee-db84-4a3d-afc3-82c0b3701074)
port provnet-729dbbee-db84-4a3d-afc3-82c0b3701074
addresses: ["unknown"]
...
$ ovn-nbctl lsp-get-type provnet-729dbbee-db84-4a3d-afc3-82c0b3701074
localnet
$ ovn-nbctl lsp-get-options provnet-729dbbee-db84-4a3d-afc3-82c0b3701074
network_name=providernet
If VLAN is used, there will be a VLAN tag shown on the localnet port as well.
Finally, create a Neutron port on the provider network.
$ neutron port-create provider
or if you followed the VLAN example, it would be:
$ neutron port-create provider-101
Skydive¶
Skydive is an open source real-time network topology and protocols analyzer. It aims to provide a comprehensive way of understanding what is happening in the network infrastructure. Skydive works by utilizing agents to collect host-local information, and sending this information to a central agent for further analysis. It utilizes elasticsearch to store the data.
To enable Skydive support with OVN and devstack, enable it on the control and compute nodes.
On the control node, enable it as follows:
enable_plugin skydive https://github.com/skydive-project/skydive.git
enable_service skydive-analyzer
On the compute nodes, enable it as follows:
enable_plugin skydive https://github.com/skydive-project/skydive.git
enable_service skydive-agent
Troubleshooting¶
If you run into any problems, take a look at our Troubleshooting page.
Additional Resources¶
See the documentation and other references linked from the Team and repository tags page.


Sore throats are very common and usually nothing to worry about. They normally get better by themselves within a week.
How to treat a sore throat yourself
To help soothe a sore throat and shorten how long it lasts, you can:
- gargle with warm, salty water (children should not try this)
- drink plenty of water
- eat cool or soft foods
- avoid smoking or smoky places
- suck ice cubes, ice lollies or hard sweets – but do not give young children anything small and hard to suck because of the risk of choking
- rest
How to gargle with salt water
- Dissolve half a teaspoon of salt in a glass of warm water (warm water helps salt dissolve).
- Gargle with the solution, then spit it out (do not swallow it).
- Repeat as often as you like.
A pharmacist can help with sore throats
You can ask a pharmacist about ways of relieving the pain and discomfort of a sore throat, such as:
- paracetamol or ibuprofen
- medicated lozenges containing a local anaesthetic, antiseptic, or anti-inflammatory medicine
- anaesthetic spray (although there's little proof they help)
You can buy these treatments from a supermarket or from a pharmacist without a prescription.
Call your pharmacy or contact them online before going in person. You can get medicines delivered or ask someone to collect them.
Antibiotics
You do not normally need antibiotics for a sore throat because they will not usually relieve your symptoms or speed up your recovery.
They'll only be prescribed if a GP thinks you could have a bacterial infection.
Non-urgent advice: See a GP if:
- your sore throat does not improve after a week
- you often get sore throats
- you're worried about your sore throat
- you have a sore throat and a very high temperature, or you feel hot and shivery
- you have a weakened immune system – for example, because of diabetes or chemotherapy
A severe or long-lasting sore throat could be something like strep throat (a bacterial throat infection).
Coronavirus (COVID-19) update: how to contact a GP
It's still important to get help from a GP if you need it.
Causes of sore throats
Sore throats are usually caused by viruses (like cold or flu) or from smoking. Very occasionally they can be caused by bacteria.
A sore throat can also be caused by:
- laryngitis
- tonsillitis
- strep throat (a bacterial throat infection)
- glandular fever
Page last reviewed: 05 February 2021
Next review due: 05 February 2024


Random Quote Machine
I hereby show you some interesting quotes that may interest you and you'll find them profitable!
Chuck Norris Jokes!
Boring Stuff
Tweet the current quote!


--- layout: page title: Graphing with Flot - Controlling Series Color group: canvas tags : [javascript, html5, canvas, graph, flot, colors, stacked] blog: /2013/02/03/graphing-with-flot-controlling-series-color/ --- {% include JB/setup %}
colors
array to create a custom palette of colors to chose from (regardless of the number of series). I used
jQuery.Color to construct the Mono and Multi options below such that I could work in the HSL color space to manipulate hue and lightness
before converting to RGB. Additionally, I set a yaxis.max
so the graph would maintain a consistent scale when adding/removing series.
This example also makes use of the jQuery UI Buttonset widget to make for a consistent and enhanced layout.


:: USA
The United States has competed at every edition of the Olympic Winter Games, and has hosted the Games on a record four occasions. The United States collected its greatest gold medal haul at the 2002 Salt Lake City Games, winning 10 gold. Four years ago in Vancouver the US team finished with its biggestoverall medal haul in winter Olympic history, with a total of 37 medals, including nine gold.


| Switch | %CPU | %Memory | %Disk | %Disk Part. | Up Days | Links | Ports | Ports Down |
|---|
| Link | Switch 1 | Port 1 | Switch 2 | Port 2 | Speed | Status | Counters | Flows |
|---|
| Switch | Port | VLAN | Member | Member MAC | Member MAC Vendor |
|---|
IX Metrics provides real-time monitoring of traffic in a layer 2 Internet exchange. The application relies on standard sFlow instrumentation in the switches to provide measurements.
Note: Certain IX Metrics features rely on the following sFlow extensions:
The following configuration steps are required:
Note: Set the oui.names=resources/config/oui.txt sFlow-RT System Property to include Member MAC Vendor values in the Locations table.
Switch configurations contains a repository of links describing how to configure sFlow on different vendor's switches.
Apply the following settings to every switch and port in the exchange (include all leaf, spine and host ports):
| Port Speed | Sampling Rate | Polling Interval |
|---|---|---|
| 1 Gbit/s | 1-in-1,000 | 20 seconds |
| 10 Gbit/s | 1-in-10,000 | 20 seconds |
| 25 Gbit/s | 1-in-25,000 | 20 seconds |
| 40 Gbit/s | 1-in-40,000 | 20 seconds |
| 50 Gbit/s | 1-in-50,000 | 20 seconds |
| 100 Gbit/s | 1-in-100,000 | 20 seconds |
For switches that allow sampling direction to be specified, enable ingress only sampling. Sampling direction must be the same for all switches.
Note: sFlow instrumentation is build into data center switch ASICs and enabling monitoring should not impact performance. However, not all implementations are equal and it is prudent to verify that these settings do not generate excessive management CPU load and that switches don't drop samples during traffic peak loads.
IX Metrics topology configuration is a JSON object. The following example illustrates the format:
{ "links": { "L1": { "node1": "leaf1", "port1": "swp1s0", "node2": "spine1", "port2": "swp49" }, ... } }
The topology.json file can be manually posted via the Settings tab in IX Metric's web interface, or through the REST API, e.g.:
curl -H 'Content-Type:application/json' -X PUT --data @topology.json http://localhost:8008/app/ix-metrics/scripts/metrics.js/topology/json
The above example is equivalent to the following Prescriptive Topology Manager (PTM) dot file:
graph G { graph [hostidtype="hostname", version="1:0"]; "leaf1":"swp1s0" -- "spine1":"swp49"; ... }
The ptm.py script converts a PTM dot file to IX Metric's JSON format, for example:
wget https://raw.githubusercontent.com/pphaal/acl_server/master/ptm.py chmod +x ptm.py ptm.py < topology.dot > topology.json
The topology must contain all inter-switch links, in particular when monitoring a CLAG pod, include the peer switch connections.
Note: If PTM is not being used to verify switch configurations, Topology discovery with Cumulus Linux describes an alternative method using LLDP.
Arista EOS Central: Fabric Visibility article provides scripts for retrieving topology using eAPI
If switches do not implement the extensions that allow naming information to be exporting using sFlow, then configuring sFlow-RT Properties to enable SNMP simplifies the contruction of the topology links information since the topology can be expressed in terms of sysName and ifName. Alternatively, a nodes section can be added to the topology to provide the mapping from switch and port names to sFlow agent address and port SNMP ifIndex numbers, e.g.
{ "nodes": { "leaf1": { "agent":"<IP_ADDRESS>", "ports":{ "swp1s0":{"ifindex":"4"}, ... } } }, "links": { ... }
The IX-F Member Export JSON Schema V1.0 is used to identify exchange members and their assigned MAC addresses.
Members information can be manually posted via the Settings tab in the IX Metric's web interface, or through the REST API, e.g.:
curl -H 'Content-Type:application/json' -X PUT @members.json http://localhost:8008/app/ix-metrics/scripts/metrics.js/members/json
Note: The Traffic>Unknown charts show traffic from MAC addresses entering or leaving the IX fabric that haven't been assigned to members. Events are generated as well, identifying the member associated with the unknown MAC address if it originated from their IP address.
The Switches and Links pages can be used to verify that all the switches and links specified in the topology are being monitored. Each page has a refresh button in the summary bar that retrieves current information and updates the display.
Switches in the topology where sFlow is being received are shown. Click on the green + icon to get details about a particular switch and its interfaces.
All the links in the specified topology are shown along with information indicating operational status and reception of counter and flow data from each both ends of the link.
Top protocols by Ethernet packet type. Click on a peak in the chart to see top protocols at that time.
Top source member, destination member, and source member to destination member flows. Click on peaks in the charts to see values at that time.
Top source and destination MAC addresses that cannot be mapped to members. Click on peaks in the charts to see values at that time.
Charts are used to identify missing / incorrect information in the members configuration. The Locations tab can be used to locate the unknown addresses. Install an updated configuration and check the charts to verify that the traffic can be identified.
Trend of Ethernet frame size distribution for packets entering exchange.
Top switch ports by ingress and egress utilization. Click on a peak in the chart to see the top ports at that time.
Top switch ports by ingress and egress packet discard rates. Click on a peak in the chart to see the top ports at that time.
Top switch ports by ingress and egress packet error rates. Click on a peak in the chart to see the top ports at that time.
The Locations tab contains a table that lists MAC addresses and the switch and port connecting them to the exchange. The table has a search box in the top right that can be used find a member by its MAC, name, or to find the hosts connected to a specific switch. Click on the refresh button in the Summary section to ensure that the most recent location information is available.
IX Metric supports InfluxDB as a time series database for storing metrics. Grafana can be used to query the database and build custom dashboard templates for managing the exchange and for exchange members.
IX Metric can send events using the syslog protocol to SIEM tools such as Logstash or Splunk.
Configure the following sFlow-RT System Properties to forward events and metrics:
| Property | Default | Description |
|---|---|---|
| ix.influx.host | InfluxDB host | |
| ix.influx.db | ix | InfluxDB database name |
| ix.syslog.host | Syslog host | |
| ix.syslog.port | 514 | Syslog port |
The IX Metrics user interface is built on a set of REST API calls that can be used to configure the software and retrieve data.
| URL | Operations | Description |
|---|---|---|
| scripts/metrics.js/topology/json | GET, PUT, POST | Manage topology |
| scripts/metrics.js/members/json | GET, PUT, POST | Manage members |
| scripts/metrics.js/metric/json | GET | Get latest metric values |
| scripts/metrics.js/metric/{name}/json | GET | Get latest value of named metric |
| scripts/metrics.js/matrix/json | GET | Get inter-member traffic matrix |
| scripts/metrics.js/bgp/json | GET | Get BGP peering connections |


Are you sure you want to delete that Record?
This action cannot be undone.
Are you sure you want to delete these Records?


- Candidate -
Class in resources
-
Class representing a candidate
- Candidate(String)
- Constructor for class resources.Candidate
-
The constructor of the class Candidate
- Candidate - Class
in types
-
candidate
Updated by JCasGen Fri Dec 18 15:02:47 CET 2015
XML source:
/comptes/E103642E/Documents/2015-2016/DeveloppementLogiciel/atal2.dlp/workspace/Mauima/src/main/resources/types/typeSystemDescriptor.xml
- Candidate() - Constructor for
class types.Candidate
-
Never called.
- Candidate(int,
TOP_Type) - Constructor for class types.Candidate
-
Internal - constructor used by generator
- Candidate(JCas) -
Constructor for class types.Candidate
-
- Candidate(JCas,
int, int) - Constructor for class types.Candidate
-
- CANDIDATE_KEY
- Static variable in class annotators.CandidateAnnotator
-
The key of the resource giving all candidates for each files
- CANDIDATE_KEY -
Static variable in class annotators.CandidateConsumer
-
The key of the resource containing all candidates for each handled files
- CANDIDATE_KEY - Static
variable in class annotators.CandidateWithVocabAnnotator
-
The key of the resource to store candidates
- CANDIDATE_KEY -
Static variable in class readers.CandidateReader
-
The name of the key for the resource containing Candidates
- Candidate_Type
- Class in types
-
candidate
Updated by JCasGen Fri Dec 18 15:02:47 CET 2015
- Candidate_Type(JCas,
Type) - Constructor for class types.Candidate_Type
-
initialize variables to correspond with Cas Type and Features
- CandidateAnnotator
- Class in annotators
-
Analysis engine to annotate candidates
- CandidateAnnotator()
- Constructor for class annotators.CandidateAnnotator
-
- CandidateClassifier
- Class in pipelines
-
Pipeline to classify candidates
- CandidateClassifier()
- Constructor for class pipelines.CandidateClassifier
-
- CandidateConsumer
- Class in annotators
-
Analysis engine to save all candidates into a file
- CandidateConsumer() -
Constructor for class annotators.CandidateConsumer
-
- CandidateCreator
- Class in pipelines
-
Pipeline to generate candidates with or without a vocabulary
- CandidateCreator()
- Constructor for class pipelines.CandidateCreator
-
- CandidateList - Interface in resources
-
- CandidateList_Impl
- Class in resources
-
A class to represent a resource representing candidates for each file to handle
- CandidateList_Impl()
- Constructor for class resources.CandidateList_Impl
-
- CandidateReader - Class in readers
-
A custom reader
- CandidateReader() - Constructor for
class readers.CandidateReader
-
- CandidateWithVocabAnnotator
- Class in annotators
-
Analysis engine to annotate candidates using a vocabulary, formatted in an rdf file with
skos
- CandidateWithVocabAnnotator()
- Constructor for class annotators.CandidateWithVocabAnnotator
-
- CandidateWithVocabCreator
- Class in pipelines
-
Pipeline to generate candidates using a vocabulary
- CandidateWithVocabCreator()
- Constructor for class pipelines.CandidateWithVocabCreator
-
- collectionProcessComplete()
- Method in class annotators.CandidateConsumer
-
Method to make some treatments after the pipeline has ended
- collectionProcessComplete()
- Method in class annotators.WekaModelBuilder
-
Method to make some treatments after the pipeline has ended
- compareTo(Pair<FIRST,
SECOND>) - Method in class utils.Pair
-
Method to compare two pairs
- computeClass(Candidate,
String) - Method in class readers.CandidateReader
-
Compute the class of a candidate


Helen Cheng is an undergraduate currently attending the University of California, San Diego. She is completing a B.S. in Joint Mathematics/Economics as well as a minor in Computer Science. Her interests include web development, data analysis, and entreprenuership.


{% block content %}
Home
SpaceX Launch Search by Mission Name
{{ form.mission_names.label }} {{ form.mission_names }}
{{ form.submit }}
{% if request_method == 'POST' %}
Mission Patch:
Mission Details:
{{ data | safe }}
Links:
Article Link:
{{ article_link }}
Wikipedia:
{{ wiki }}
{% endif %} {% endblock %}


Did you know...
Being Woke is to be aware of what is going on in the world. It is usually associated with social injustice.


Dice Game
Player One:
Player One:
Start New Game
Player 1
Current Roll
Current Turn Score
Total Score
Player 2
Current Roll
Current Turn Score
Total Score
Roll
Hold


Class Config
Config provides easy access to Yiinitializr configuration file
Namespace: Yiinitializr\Helpers
Package: Yiinitializr\helpers
Author: Antonio Ramirez<EMAIL_ADDRESS>Since: 1.0
Located at Helpers/Config.php
Package: Yiinitializr\helpers
Author: Antonio Ramirez<EMAIL_ADDRESS>Since: 1.0
Located at Helpers/Config.php
Methods summary
public static
mixed
|
|
public static
array|mixed
|
|
public static
|
|
public static
string
|
|
public static
string
|


Likes:
{{ likes.total_likes }}
{% if user.is_authenticated %}
{% endif %}
Comments: {{ product.comments.count }}
View comments for this product
{% include 'products/like_button_script.html' %}


CAM: Causal Additive Model (CAM)
The code takes an n x p data matrix and fits a Causal Additive Model (CAM) for estimating the causal structure of the underlying process. The output is a p x p adjacency matrix (a one in entry (i,j) indicates an edge from i to j). Details of the algorithm can be found in: P. Bühlmann, J. Peters, J. Ernest: "CAM: Causal Additive Models, high-dimensional order search and penalized regression", Annals of Statistics 42:2526-2556, 2014.
| Version: |
1.0 |
| Depends: |
glmnet, mboost, Matrix, parallel, mgcv |
| Published: |
2015-03-05 |
| Author: |
Jonas Peters and Jan Ernest |
| Maintainer: |
Jonas Peters <jonas.peters at tuebingen.mpg.de> |
| License: |
FreeBSD |
| NeedsCompilation: |
no |
| CRAN checks: |
CAM results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=CAM
to link to this page.


--- title: Losses keywords: fastai sidebar: home_sidebar summary: "Implements custom loss functions." description: "Implements custom loss functions." nb_path: "nbs/05_losses.ipynb" ---
as described by Falk, Thorsten, et al. "U-Net: deep learning for cell counting, detection, and morphometry." Nature methods 16.1 (2019): 67-70.
axis
for softmax calculations. Defaulted at 1 (channel dimension).reduction
will be used when we call Learner.get_preds
activation
function will be applied on the raw output logits of the model when calling Learner.get_preds
or Learner.predict
decodes
function converts the output of the model to a format similar to the target (here binary masks). This is used in Learner.predict
In a segmentation task, we want to take the softmax over the channel dimension
torch.manual_seed(0)
tst = WeightedSoftmaxCrossEntropy(axis=1)
output = TensorImage(torch.randn(4, 5, 356, 356, requires_grad=True))
targets = TensorMask(torch.ones(4, 356, 356).long())
weights = torch.randn(4, 356, 356)
loss = tst(output, targets, weights)
test_eq(loss.detach().numpy(), -0.002415925730019808)
test_eq(tst.activation(output), F.softmax(output, dim=1))
test_eq(tst.decodes(output), output.argmax(dim=1))
output = TensorImage(torch.randn(4, 5, 356, 356, requires_grad=True))
targets = TensorMask(torch.ones(4, 356, 356).long())
tst = load_kornia_loss("TverskyLoss", alpha=0.5, beta=0.5) # equals dice loss
loss = tst(output, targets)
tst2 = load_kornia_loss("DiceLoss")
loss2 = tst2(output, targets)
test_eq(loss.detach().numpy(), loss2.detach().numpy())
tst3 = load_kornia_loss("FocalLoss")
loss3 = tst3(output, targets)


{% load i18n%} {% load consulting %} {% url consulting_newpatient as newpatient %} {% url consulting_today as today %} {% url consulting_index_pm as index_pm %} {% url stratification_statistic as index_statistic %} {% url private_messages_inbox as inbox %} {% url cal.index as calendar %}


The MeloSol Corpus
Earlier this month I learned some of the research from my dissertation was accepted for publication! Publications are always reason to celebrate, but this one is especially deserving because of the amount of work that went into this project. I love sharing what I have been up to so of course I am going to write a post about it for those that are interested.
You can find the pre-print here.
Need 4 Data
Let me begin by making a gross generalization: the harder data is to get, the more useful it is going to be.
Of course that’s not a hard and fast rule, but it is easy to imagine a one dimensional continuum with large randomized clinical trials on one end and taking a tally of your friend’s opinion on the outcome of the next presidential election on the other. Aspects of randomization and large sample sizes in experimental designs that are set up to answer a specific question regarding the efficacy of some treatment will, in theory, but much more reliable than the convenience, collider conditioned sample of something notoriously as difficult to predict as an election. Most data probably exists somewhere between these extremes.
I would bet that many fields of research have their own version of this continuum and I know my area of expertise in computational musicology is no different. Yes, we have a lot of data sets out there that you can use, but the thing is that if you study something as big and amorphous as “music”, you’re rarely going to be able to find what you want in terms of a usable data set if you have a very specific question you want to answer.
There are tons of great music datasets from the music information retrevial world, but many of these data sets tend to deal with audio data (like the waveform playing music to your headphones) rather than something that looks like sheet music.
There’s tons of cool stuff that can be done with audio data (recommendation systems, the Shazam algorithm, dynamic time warping), but it’s very difficult to work with “the notes” (as a music theorist) with this kind of data. You need a digitized version of the score to be able to do this.
There are a lot of ways to do get your data into one of the many helpful formats like MIDI, MEI, and kern, each with their own advantages and disadvantages, but the problem is just getting a paper score into these formats.
More often than not, especially with MEI and kern, you need to have this data entered manually. Someone, somewhere needs to sit down and plop in each note into an application like MuseScore.
This process is unbelievably boring. It’s so boring that one of the software toolboxes for manipulating kern files is literally called humdrum.
So if you want to ask a new musical question, you pretty much have two choices.
You can head over to something like kern scores and see what is there, with odds being that you’re not going to find exactly what you need OR you can make a new dataset. Seeing that grad school is all about contributing something new and helpful to the research community at large, I saw it as a worthwhile investment in myself and my community to do the latter.
Specifically, what I am interested in is how people learn1 melodies (both explicitly and implicitly). For my Ph.D., I wanted a dataset that I could use that had melodies that are used when people learn melodies.
There of course was no ready-to-go dataset called “Learnable Melodies” and the closet thing to this was this giant dataset that has been around since the mid 1990s (a dataset older than many undergrads right now) that has thousands of folk song melodies called the Essen Folk Song Collection which has over 6,000 monophonic (meaning a single line) melodies. It’s kind of close to what I wanted, but not exactly.
In being interested in how people learn melodies also comes with this idea in the music and science literature that sort of assumes that if you have this big database of all these melodic patterns, you can use these patterns to help find meaningful correlates to human responses to music.
This was an idea got a lot of attention first from this great book by Leonard Meyer called Emotion and Meaning in Music that linked the musical structure to how people hear music, but as of recently if you really want to dig into this area the canonical citation is David Huron’s Sweet Anticipation.
In this book, Huron does some really neat stuff following up on Meyer’s ideas and this book continues to be the gateway drug to computational musicology for many people.
I remember being really inspired reading this book before and during grad school and then getting even more into these ideas reading about some of the computational models of auditory cognition via the work of Marcus Pearce’s IDyOM model and the multiple viewpoints paper that inspired this work.
Both the work of Huron and Pearce have used corpora like the Essen collection extensively and it acts as the training data for many of these statistical models of music cognition. To relate this work to things in popular culture, the Google Doodle that I wrote about a while ago was trained using similar data that the multiple viewpoints paper was trained on.
So I figured if I wanted to be a part of this conversation at the academic table, I should start by contributing something that might be helpful.
So as a psychological fail safe, during my Ph.D. I digitized 783 melodies from a sight-singing book.2
This meant entering over 36,000 notes by hand into MuseScore over the however many months I was writing my dissertation. It was not fun, but I am glad that I did it because now there’s a new dataset on the block called the MeloSol corpus! I ended up calling it the MeloSol corpus since it’s Mel odic data and the name of the first author of the book is someone named Sol. A very appropriate name for an author of an aural skills book.
So What?
So now that it’s been digitized, what can you do with it?
Well if you’re part of this very niche world of computational musicology, you can just read the pre-print, but if this is your first time even realizing computational musicology is a thing3 let me take you through a walk through of what’s here using the data visualizations I made as a guide.
Let’s start with the first two figures (panels of four images each).
FIGURE 1
FIGURE 2
These first two images are pretty much what an exploratory data analysis (EDA) look like if you’re a computational musicologist. They go beyond the fact that the data is 783 melodies made up of 49,730 analyzable tokens (basically notes and rests) and starts to look at sub-groups of interest. From the figures we can see that there happen to be more melodies in major rather than minor, what keys you can expect to find, and how long (measured in number of notes) the melodies are.
We can also see from the bottom right corner of Figure 2 that my little corpus of 783 melodies is about 1/10th the size of the Essen I was talking about before. This is important to point out because one thing I am interested in as a researcher is how big your dataset actually has to be before you can start getting anything helpful out of it. In Figure 3 I also ran the FANTASTIC toolbox over all the corpora to show the distribution of these abstracted features.
FIGURE 3
The fourth figure plots another aspect that might not be of immediate interest to non-music-psychology readers which is the contour or shape of a melody.
FIGURE 4
Contour is not really something most people think or talk about when it comes to picking vocabulary to describe why they like certain melodies (unless you’re working your way through Dr. Jacob Gran’s counterpoint vidoes), but contour plays a very big role in the melody literature.
I won’t get into that here, but through this Figure I just wanted to show the high level similarity between my little MeloSol corpus and some of the other corpora that are also single line melodies. We have the Essen collection (split between geographic region since there is an Asian subset of it) as well as some Densmore melodies.
Up until this point, these are pretty much summary features of a melody answering questions you can measure either directly (what is the range, length) or indirectly (tonalness via a toolbox that approximates a measurement for it), but really what I would like as an end goal with this corpus is to have people start using the MeloSol in tandem with the Essen in exploring these claims I mentioned above about our latent understanding being mapped to corpora, so I went a bit deeper in comparing the MeloSol and the Essen.
We dive into that comparison in the next two figures.
Comparing Corpora
This gets a little more complicated, but not beyond the grasp of most people who have found this post. Figure 5 was an attempt to start to answer the question how similar these two corpora are.
FIGURE 5
It’s kind of a difficult question because you need to come up with a way to operationalize similarity4, but it’s an important question because when working with music data it is MUCH harder to get more data if you want it.
Setting aside the annoying process of encoding it, most of our historical musical data comes from a finite population (borrowing the actual statistics definition here). Unlike trying to find the “true” average number of times a cat meows the longer you go without remembering to feed them– a task you can accomplish by just running lots of experiments on lots of cats in many conditions– you can’t really get more Bach or Davis if you had lots of hypotheses you want to test.5
So instead of getting multiple datasets to keep testing ideas (like how the frequentists think about probability in the long run with many samples trying to model P(D|H)), we could try to Bayes it out (P(H|D)), but another approach that is a bit more brute force is this thing called bootstrapping your sample.
There’s a great video here on it here, but the TLDR is that you just pretend that the data that is in front of you is the theoretical population you never really get to know the “true” values of and just take lots of combinations of data to see how stable the relationships are in your dataset.
This is basically what I wanted to do with these two corpora.
The analysis in Figure 5 does this on the musical intervals that are present in the corpora. For those without a music reading background, a musical interval is the distance between two notes. So if you think of the first two notes of “Here comes the bride!”, instead of describing this as one being played (“Here”) then jumping up and repeating three times ("comes the bride!), we just call that musical moment by the distance jumped.
If you think of a melody as just a bunch of intervals, and then these strings of intervals (melodies) as belonging to a bigger collection (the corpus) we can then have two big pools of data to compare to one another. One is a big pool of all the intervals that come from the MeloSol corpus and the other the Essen. The idea being that if you just grabbed random collections from each pool, could you know what pool you were pulling out of if you all you had to look at was the intervals you were seeing?
If you couldn’t tell, you’d probably assume the corpora were very similar, but if it was kind of obvious, you’d consider them to be different. And don’t just do this a few times, but like 100,000 times. How often to certain intervals emerge from your sample?
So what Figure 5 shows you is basically that thought experiment run on both of the corpora. The little dots from each color representing each corpora appear very close to one another suggesting that the intervals are drawn from our big pool with similar proportions, suggesting superficial similarities between the two.
Now some more “musically” minded people might be like, yeah, no duh they are similar since they come from Western music (remember, that’s the point I am trying to make) but surely this task would be easier if you got to pull out strings that were longer than just one interval.
That’s what Figure 6 tries to quantify.
FIGURE 6
This figure shows what happens when you try to count up all the unique strings of various length and compare how similar they are using a rank order correlation. As you might expect, when you have shorter strings, the two pools are very closely related (having a correlation coefficient near 1), and the more unique intervals you plop on, the more dissimilar they get.
Now this is quite a rough way to talk about similarity on the large level, and if this interests you but not like on this coarse level, there’s more of an applied theoretical link to this in the latest MTO with Brian Miller talking about this with Leonard Meyer’s theory of style.
This whole analysis is all to just hopefully show that there is a new corpus on the block with similar properties to the one we all have been using that is smaller and a bit more manageable and probably actually is closer to what we mean when we talk about the expectations of Western tonal music than all these European folk songs.
So will people use it? Who knows, but I know I have. I’ve used it with great success for a new project that will get its own post when it comes out.
If you have questions about this or computational musicology in general, please get in touch!
Not about to split hairs on the definition of learning here↩
For the uninitiated, sight-singing is a skill most undergraduates majoring in music need to learn that allows you to look at a piece of music and know how it sounds without playing it on an instrument.↩
Hello LinkedIn reader who thought they were about to read about data science↩
woof↩
I will take an aside here to point out how ridiculous this is to even assert that something like a p value would be meaningful in this context given the finite sample…↩


Fullscreen examples
Example 1: Define fullscreen element via href-target.
Example 2: data-attr configuration: ``selector`` and ``close-button``.
Example 3: Existing ``.close-fullscreen`` elements.
Example 4: No fullscreen element definition opens fullscreen on body.
Example 1
Example 2
Example 3
Close fullscreen Link
Close Fullscreen Button
Reload site without close fullscreen.


Hey {{masterName}}, we received a request about deleting your own post.
You said in {{title}} :
{{content}}
If this request is submitted by yourself, please click this to confirm the operation.
This email was sent automaticlly.


[gecode-users] BPPC'08: 2nd Call for Papers
Mats Carlsson
matsc at sics.se
Wed Mar 12 12:24:49 CET 2008
Second Call for Papers
BPPC'08
First Workshop on Bin Packing and Placement Constraints
associated to CPAIOR 2008
May 22, 2008, Paris, France
http://contraintes.inria.fr/CPAIOR08/BPPC.html
http://contraintes.inria.fr/CPAIOR08
____ Scope ____
Bin Packing and Placement problems are an old but still challenging
topic that has been tackled with different approaches.
On the one hand, the aim of this workshop is to share recent progress
made on pure problems by using any technique (or the mix) like Mixed
Integer Linear Programming, Local Search, or Constraint Programming.
On the other hand, the aim is to present challenging problems formulated
and/or solved by these methods, or challenging extensions that have a
practical interest and for which pure methods do not directly work.
Submitted papers can be
* Extended Abstracts of new results or
* Abstract of ongoing works
* Systems presentations (with demos at the workshop)
* Summaries of already accepted or recently published results
on any topic concerning bin packing and placement constraints.
For registration, travel, accomodation and venue, see the CPAIOR 2008
web site.
____ Important Dates ____
NEW Submission Deadline: March 26, 2008
Notification to Authors: April 15, 2008
Camera-ready due: April 30, 2008
Workshop: May 22, 2008.
____ Submission ____
Submission site:
http://www.easychair.org/conferences/?conf=bppc08
Submission format is PDF or PS in the standard llncs style.
Page limit is 6 pages.
Authors can refer to long papers but only short papers will be reviewed.
Workshop participation of at least one author is mandatory.
Participation to CPAIOR is strongly encouraged.
____ Program Committee ____
Nicolas Beldiceanu (EMN, France)
Mats Carlsson (SICS, Sweden)
François Clautiaux (Univ. Lille, France)
François Fages (INRIA, France)
Richard Korf (UCLA, USA)
Andrea Lodi (Univ. Bologna, Italy)
Silvano Martello (Univ. Bologna, Italy)
Michael Moffitt (IBM Austin, USA)
________________________________________________________________________
This workshop is sponsored by the European project NET-WMS.
http://net-wms.ercim.org/
More information about the gecode-users
mailing list


Stay wary of Covid-19 !!
Keep ya-self update with the latest stats of Covid,
tailored specifically for your country!
Stay wary of Covid-19 !!
Keep ya-self update with the latest stats of Covid,
tailored specifically for your country!
Our Bot has Some Other Special Features
It Provid Imortant links and Brief Information regarding Medicins, Vaccine and Vaccination.
Bot Stores the Leads likes Oxygen, Plasma, or other Medical Aids
which can help a Covid Patient Provided by different users.
Admin can also verify the Leads,
And bot can show different separate Table of
Verified Leads !!
(Sorting is also Enabled)
Moreover User can Sort the Leads by their Needs.
Bot Stores the Needs likes Oxygen, Plasma, or other Medical Aids which is being Requested by a User.
And bot can show different separate Table of Needs !! for the Ease of Provider (Sorting is also Enabled)
Moreover User can Sort the Needs by Required Item.
Getting bored, interested in space?
CovBot will cater to your needs,
Get to see NASA's Picture Of The Day !!
BONUS!! You can Search for Anything Related to Space !!
Feeling depressed or tensed?
Time for some inspiration !!
Get a Quote out of the Thousands of Quotes that we have Stored for You!!
Interested in Anime and Manga ?
We got you Covered !!
Get Anime and Manga Ratings, Episode Counts,
And brief Description using just a Keyword!
If you like to keep up-to date with the world,
CovBot got you covered !!
Search for any topic you can think of and get the search results !!
You Like Cute Pictures??
Want to keep them as your Wallpaper?
We got you Covered !!
One Click Download and Enjoy !!


| vec_bind {vctrs} | R Documentation |
This pair of functions binds together data frames (and vectors), either row-wise or column-wise. Row-binding creates a data frame with common type across all arguments. Column-binding creates a data frame with common length across all arguments.
vec_rbind( ..., .ptype = NULL, .names_to = rlang::zap(), .name_repair = c("unique", "universal", "check_unique"), .name_spec = NULL ) vec_cbind( ..., .ptype = NULL, .size = NULL, .name_repair = c("unique", "universal", "check_unique", "minimal") )
... |
Data frames or vectors. When the inputs are named:
|
.ptype |
If Alternatively, you can supply |
.names_to |
This controls what to do with input names supplied in
|
.name_repair |
One of With |
.name_spec |
A name specification (as documented in |
.size |
If, Alternatively, specify the desired number of rows, and any inputs of length 1 will be recycled appropriately. |
A data frame, or subclass of data frame.
If ...
is a mix of different data frame subclasses, vec_ptype2()
will be used to determine the output type. For vec_rbind()
, this
will determine the type of the container and the type of each column;
for vec_cbind()
it only determines the type of the output container.
If there are no non-NULL
inputs, the result will be data.frame()
.
All inputs are first converted to a data frame. The conversion for 1d vectors depends on the direction of binding:
For vec_rbind()
, each element of the vector becomes a column in
a single row.
For vec_cbind()
, each element of the vector becomes a row in a
single column.
Once the inputs have all become data frames, the following invariants are observed for row-binding:
vec_size(vec_rbind(x, y)) == vec_size(x) + vec_size(y)
vec_ptype(vec_rbind(x, y)) = vec_ptype_common(x, y)
Note that if an input is an empty vector, it is first converted to a 1-row data frame with 0 columns. Despite being empty, its effective size for the total number of rows is 1.
For column-binding, the following invariants apply:
vec_size(vec_cbind(x, y)) == vec_size_common(x, y)
vec_ptype(vec_cbind(x, y)) == vec_cbind(vec_ptype(x), vec_ptype(x))
vec_rbind()
If columns to combine inherit from a common class,
vec_rbind()
falls back to base::c()
if there exists a c()
method implemented for this class hierarchy.
vec_c()
for combining 1d vectors.
# row binding ----------------------------------------- # common columns are coerced to common class vec_rbind( data.frame(x = 1), data.frame(x = FALSE) ) # unique columns are filled with NAs vec_rbind( data.frame(x = 1), data.frame(y = "x") ) # null inputs are ignored vec_rbind( data.frame(x = 1), NULL, data.frame(x = 2) ) # bare vectors are treated as rows vec_rbind( c(x = 1, y = 2), c(x = 3) ) # default names will be supplied if arguments are not named vec_rbind( 1:2, 1:3, 1:4 ) # column binding -------------------------------------- # each input is recycled to have common length vec_cbind( data.frame(x = 1), data.frame(y = 1:3) ) # bare vectors are treated as columns vec_cbind( data.frame(x = 1), y = letters[1:3] ) # if you supply a named data frame, it is packed in a single column data <- vec_cbind( x = data.frame(a = 1, b = 2), y = 1 ) data # Packed data frames are nested in a single column. This makes it # possible to access it through a single name: data$x # since the base print method is suboptimal with packed data # frames, it is recommended to use tibble to work with these: if (rlang::is_installed("tibble")) { vec_cbind(x = tibble::tibble(a = 1, b = 2), y = 1) } # duplicate names are flagged vec_cbind(x = 1, x = 2)


My Team
Bob
Manager
ID: 1
<EMAIL_ADDRESS>Office Number: 1
Steve
Engineer
ID: 2
<EMAIL_ADDRESS>Github:
steve
,
Eric
Engineer
ID: 3
<EMAIL_ADDRESS>Github:
eric
Leigh
Intern
ID: 4
<EMAIL_ADDRESS>School: A&M
John
Intern
ID: 5
<EMAIL_ADDRESS>School: Yale


Popular throughout Spain, tapas are festive and delicious appetizers and snacks that are perfect for get-togethers or summer dinner parties. These tapas are delicious, easy, and fun to make.
Ingredients
- 4 tablespoons olive oil
- 5 cloves garlic, finely minced
- 1 pint red grape tomatoes, halved lengthwise
- 1 pint yellow grape tomatoes, halved lengthwise
|
- 1 tablespoon balsamic vinegar
- 16 whole fresh basil leaves, plus more as needed, chiffonade
- Salt and freshly ground black pepper
- 1 whole baguette or crusty loaf
|
|
|
Method
- In a small skillet, heat the oil over medium-high heat. Add the garlic and stir, lightly frying for about a minute, removing before the garlic gets too brown (it can be golden). Pour the garlic and oil into a mixing bowl and allow to cool slightly.
- Add the red and yellow tomatoes, balsamic and basil to the bowl. Sprinkle with salt and pepper. Toss to combine, and then taste and add more basil if needed, and more salt if needed (don't over salt, though!) Cover and refrigerate for an hour or two if you have the time.
- Cut the baguette into diagonal slices to allow for the most surface area possible. Grill the bread on both sides.
- To serve, give the tomato mixture a final stir, and then spoon generously over the slices of bread. Serve on a big platter as a first course or appetizer.
|


Majid Aram
- Location
- Stockholm, Sweden
- Industry
- Information Technology and Services
As a LinkedIn member, you'll join 175 million other professionals who are sharing connections, ideas, and opportunities. And it's free! You'll also be able to:
- See who you and Majid Aram know in common
- Get introduced to Majid Aram
- Contact Majid Aram directly
Majid Aram's Overview
- Connections
-
327 connections
Majid Aram's Skills & Expertise
View Majid Aram’s full profile to...
- See who you and Majid Aram know in common
- Get introduced to Majid Aram
- Contact Majid Aram directly


--- layout: post authors: ["Greg Wilson"] title: "And Now We Are Three" date: 2015-03-17 time: "06:00:00" tags: ["Teaching"] ---
The four core topics that every Software Carpentry workshop is supposed to teach are automating tasks using the Unix shell, structured programming in Python, R, or MATLAB, version control using Git or Mercurial, and data management using SQL. In practice, many workshops omit the fourth, either because instructors want to put more time into the first three, or because they don't think SQL is relevant to their learners.
The Steering Committee has therefore voted to take SQL out of the core. This doesn't mean that it can't or shouldn't be taught: it's still useful for many researchers to know, and the best way we've found to introduce key ideas in data management like atomic values, keys, and how to handle missing information. However, if instructors and learners would rather cover something else, they can do so.
One candidate for that "something else" is quality assurance, i.e., the things we do to ensure that our code actually works. We talked last October about why we don't include testing in the core, but some instructors still do cover testing and debugging using this material from the Hacker Within, these notes from one of last year's WiSE workshops, or our Version 4 notes from five years ago. I think we should try once again to combine this with material on code review to create a half-day lesson on QA for the working scientist. I still believe that lesson will only stick if it includes examples showing how to decide what tests to run for actual scientific problems, and what tolerances to use for "right" answers, but Ian Hawke has put together some IPython Notebooks (which you can view here) to get that ball rolling.
Another candidate for "something else" is how to use Make to create a reproducible paper. Make's syntax is famously opaque, and that lesson moves far too quickly for most of our audience, but again, those are things we can fix.
Writing a usable half-day lesson takes me a week: it's one day per hour of class time to put the first version together, then another couple of days to revise it after its first delivery. Crowdsourcing doesn't help much with the first part, but definitely does with the second. If you're interested in taking a run at either of these, or at some other topic, please get in touch: I'll group interested parties together and get a new lesson repository rolling.


broadcastdelay seconds
trap host_address [ port port_number ] [
interface interface_address ]
setvar variable [ default ]
name = value
is
followed by the default
keyword, the variable will be
listed as part of the default system variables (ntpq rv
command). These additional variables serve informational purposes only.
They are not related to the protocol other that they can be listed. The
known protocol variables will always override any variables defined via
the setvar
mechanism.
sys_var_list
holds the
names of all system variables. The peer_var_list
holds the
names of all peer variables and the clock_var_list
holds
the names of the reference clock variables.
logfile logfile
syslog
facility.
logconfig configkeyword
syslog
facility or the alternate
logfile
log file. By default, all output is turned on. All
configkeyword
keywords can be prefixed with
=
, +
and -
, where =
sets the syslogmask
, +
adds and -
removes messages. syslog messages
can be controlled in four
classes (, peer
, sys
and sync
).
Within these classes four types of messages can be controlled.
info
) control configuration
information. Event messages (events
) control logging of
events (reachability, synchronization, alarm conditions). Statistical
output is controlled with the statistics
keyword. The final
message group is the status messages. This describes mainly the
synchronizations status. Configuration keywords are formed by
concatenating the message class with the event class. The
allprefix
can be used instead of a message class. A message
class may also be followed by the all
keyword to
enable/disable all messages of the respective message class.
logconfig = syncstatus +sysevents
xntpd
and the major system events. For a simple reference
server, the following minimum message configuration could be useful:
logconfig = syncall +clockall
Most variables used by the NTP protocol can be examined with the
xntpdc
(mode 7 messages) and the ntpq
(mode 6
messages). Currently, very few variables can be modified via mode 6
messages. These variables are either created with the
setvar
directive or the leap warning bits. The leap warning
bits can be set in the leapwarning
variable up to one month
ahead. Both the leapwarning
and leapindication
variables have a slightly different encoding than the usual leap bits
interpretation:
00
01/10
11
LEAP_NOWARNING
is passed on).


U.S. polo assn. full sleev plain tshirt for man
$120.00
Qty:1
size:Medium/large
Cart subtotal:
$168.20
Update Profile
� 2017 eShopper online store. All rights reserved


Monitoring data for PPE is available to view on AppLens (Prod). Click here to view the Monitoring tab on AppLens (Prod).
Analytics data for PPE is available to view on AppLens (Prod). Click here to view the Analytics tab on AppLens (Prod).


## Mako can find this base file because it's in the settings.py -> MAKO_TEMPLATES_DIRS list <%inherit file="base.htm" /> <%block name="title"> %block> <%block name="content">
Enter your username associated with your account and we will send you an email with a link to reset your password.


Circuits as Code¶
This is a collection of pre-built circuits written as scripts in SKiDL.
Description¶
SKiDL lets you create electronic circuits by writing Python scripts instead of using a schematic editor.
The circuitsascode
auxiliary Python package gives you a library of ready-made electronic circuits that serves several purposes:
It provides a set of lower-level modules that you can integrate within your own designs.
It shows you examples of how to write SKiDL code.
Usage¶
Just import the library to use a circuit module:
# Import the function that creates a VGA display interface.
from circuitsascode.displays.vga import vga
# Create color and sync signals to connect to the VGA interface.
red, grn, blu = Bus(5), Bus(4), Bus(3)
hsync, vsync, gnd = Net(), Net(), Net()
# Create a VGA interface circuit customized for the widths
# of the RGB buses.
vga1 = vga(rgb=(len(red), len(grn), len(blu)))
# Connect the signals to the VGA interface circuit.
vga1.red += red
vga1.grn += grn
vga1.blu += blu
vga1.hsync += hsync
vga1.vsync += vsync
vga1.gnd += gnd


About Me
A few words
Technically inclined passionate individual with good communication skills and advanced knowledge of mathematics & computer sciences. C++ software developer with specialization in Google Cloud Networking. A Flutter Developer(Frontend and Backend) with an experience of 2+ year. An Open Source contributor who likes to share his knowledge with others and always striving to achieve excellence. He is a self motivated learner and always on the lookout for new and interesting things who has also dabbled as a cloud developer (computer/learner) and has a sound knowledge of Data Science (NLP and Activation Functions in Neural Networks).
Projects
Services Required
I have handled and completed several projects, either alone or working as part of a team. So far I have tried my hands on some Flutter Development, Software Development, Cloud Computing and Data Science Projects with a vision to improve my skill sets and do bigger projects in the future.
Co-Founder, Intrepid Geeks
Hirdan is a highly active and dedicated person, during his work as a Mentor at intrepid Geeks in the field of Flutterhe conducted a lot of content enriched sessions with the students, all of his mentees were very satisfied with him and were appreciating his work.
Founder, !nspire Talks
Hirdan is one of the person who is tries getting multiple at a young age and that is one of the best thing about him. He is also one of the most enthusiastic and energetic person I have met at their college. Wish you all the very best Hirdan :)


This is the API documentation for 'RBatch Docs'.
[Validate]
Generated with the Darkfish Rdoc Generator 1.1.6.