File
New
Load ...
Save
Save as PNG
Edit
Add Node ...
Add Compound For Selected
Add Edge Between Selected
Delete Selected
Layout
Style
CoSE2
CoSE
Cola
Springy
Arbor
Perform Layout
Layout Properties
Cytoscape.js
_LayoutDemo
Name
Width
Height
Border Width
Border Color
X
Y
Color
Shape
Rectangle
Triangle
Ellipse
Round Rectangle
Pentagon


BangonPH
www.bangonph.com
Input short description of bangonph: Lorem ipsum
Input short description of bangonph: Lorem ipsum
Campaign
eg. feature phone donations
Relief Supply Train
Input needs of repacking sites
eg. WHITESPACE: rice, noodles
eg. WHITESPACE: rice, noodles
Google Crisis Map
News
| Input relevant news and blog posts |


Getting Started
This project aims at automating the office work at the Department of Computer Science, University of Delhi (aka DUCS). You can also read the problem description for more details.
Requirements
This project is built with Laravel and Alpine.js. The Laravel framework has a few system requirements. All of these requirements are satisfied by the Laravel Homestead virtual machine.
However, if you are not using Homestead, you will need to make sure your local development server meets the following requirements. You can also find these listed in Laravel Docs.
- PHP >= 7.3.0
- BCMath PHP Extension
- JSON PHP Extension
- Mbstring PHP Extension
- OpenSSL PHP Extension
- PDO PHP Extension
- Tokenizer PHP Extension
- XML PHP Extension
Additionally, you would require to install Composer and NPM to pull in all the project dependencies.
Installation
Using apt
package manager (Debian/Ubuntu)
Before you begin installing make sure you run sudo apt update
to get the latest version available.
# if you do not have MySQL installed on your system
sudo apt install mysql-server
# if you are running Ubuntu 18.04 or older
sudo add-apt-repository ppa:ondrej/php
sudo apt update
# PHP and required extensions
sudo apt install php7.4 php7.4-mysql php7.4-xml php7.4-mbstring php7.4-bcmath php7.4-sqlite php7.4-json
# Composer and NPM
sudo apt install composer npm
Quick Start
- Clone the project using
git
:
git clone https://github.com/ducs-office/ducs-office-automation.git
- Install project dependencies
Go to your project directory and install PHP dependencies using composer
:
composer install
Use npm
to install all the required JavaScript dependencies.
npm install
To compile down the front end assets like style sheets (CSS) and JavaScript files, use:
npm run dev
Or you can also run a watcher to automatically compile the assets, whenever the files are changed.
npm run watch
- Configure the application
Create a duplicate file of .env.example
as .env
.
cp .env.example .env
- Generate an application key using:
php artisan key:generate
The command will add an application key to your
.env
file.
- Create a new
mysql
user and database
Since the application uses MySQL DBMS, you'd require a database and valid credentials.
mysql -u root -h localhost -p
mysql> CREATE USER 'username'@'localhost' IDENTIFIED BY 'password';
mysql> GRANT ALL PRIVILEGES ON office_automation.* TO 'username'@'localhost' WITH GRANT OPTION;
mysql> ALTER USER 'username'@'localhost' IDENTIFIED WITH mysql_native_password by 'password';
mysql> \q
mysql -u username -h localhost -p
mysql> CREATE DATABASE office_automation;
- Setup
Database
connection in.env
file:
Change the following configuration values:
...
DB_DATABASE=office_automation
DB_USERNAME=username
DB_PASSWORD=password
...
- Add some default data for testing the app
To begin browsing and testing the portal, you'd need the application seeded with some dummy data.
To create all the tables and seed your database with dummy data, run:
php artisan migrate --seed
- Start Local Development Server
This will serve the project at localhost:8000
, you can now open this up in your browser using:
php artisan serve
- Default login credentials
Use the following credentials to login as admin
Email<EMAIL_ADDRESS>Password: password


Team QFX
Team QFX is a UK based Vertical Formation Skydiving (VFS) team, established in 2011. The team won Silver in the 2012 and 2013 UK skydiving Nationals, and competed in the world championships in Dubai in 2012.
All 5 team members were participants in the new 30 way 2013 UK Head Down record, and most team members also hold current European and World records.
The team achieved a major increase in average score at the UK Nationals; from 5.4 in 2012, to 8.9 in 2013. this is attributed to increased team experience, a few lineup changes and a dedicated training plan.
The team plans to keep the same lineup for 2014 and beyond,but greatly increase the amount of training, and expects to continue going from strength to strength.
Ally Milne
6000+ Jumps
400+ Hours Tunnel
AFF Instructor
Tandem Instructor
BPA Freefly Coach
Tunnel Coach
96-Way Vertical Eurorecord 2013
30-Way Vertical UK Record 2013
Ally is a full time skydiver at BPS Langar. In his free time he likes skydiving.
Paul Cooper
3000+ Jumps
130+ Hours Tunnel
BPA Freefly Coach
Tunnel Coach
138-Way Vertical World Record 2012
142-Way Illinois State Record 2012
96-Way Vertical Eurorecord 2013
30-Way Vertical UK Record 2013
Paul is an extremely experienced skydiver who likes breaking records.

Pete Dennett
1400+ Jumps
70+ Hours Tunnel
BPA Freefly Coach
Tunnel Coach
30-Way Vertical UK Record 2013
Pete lives 15 mins away from the windtunnel and it shows.
Ewan Cowie
1800+ Jumps
50+ Hours Tunnel
BPA AFF Instructor
BPA FS Coach
BPA Freefly Coach
Tunnel Coach
30-Way Vertical UK Record 2013
Ewan is passionate about freeflying, photography and sunsets and tries to combine the three.


My first post
26 Sep 2014 Hello, This is my first post using jekyll, which is a static website generator (i.e. no databases or other complicated stuff).It certainly took long time to modify the htmls and csses, but i think it was worth it.
This website is hosted on github pages, which is a free hosting for personal and projects pages,and setup to work with my domain, which i got from godaddy.com for 1.99$ for the first year using a coupon code.
In an ideal world i would have installed a more user friendly cms or blog, but unfortunately github pages don't allow mysql databases. that makes it quite impossible to have a fully functional website; however, jekyll dont use that. jekyll let you write your posts locally in any markdown language you like, and then transform them into full html pages.
I learned many new things in the process of getting this site up. The most valuable of them is using git cli, which turned out to be much better than downloading a master zip file. I also learned about dns zones and domain forwardnig.I also noticed that my html knowledge isn't that great, so i am trying to get better at html now (in fact i am writing this post in html now).
Finally i thought of making a tutorial on making a website like mine, but there are already sufficient tutorials out there, so i am linking them. hopefully when i finish my layout, i will share my layout.
*credits go to writers


@* * Copyright 2019 HM Revenue & Customs * * 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. *@ @( label: String, hint: Option[String] = None, form: Form[_] )(implicit messages: Messages)


| receipt # {{paymentRefId}} |
Purchased By |
| {{payer.contact.firstName}} {{payer.contact.lastName}} |
| email: {{payer.contact.email}} |
| phone: {{payer.contact.phone}} |
| {{ addressFormat payer.address.streets }}
{{ payer.address.city }}, {{ payer.address.stateOrProvince }} {{ payer.address.countryCode }} {{ payer.address.postalCode }}
|
Card Charged |
| last 4 digits {{last4}} |
| expires {{exp}} |
Ship To |
| {{recipient.contact.firstName}} {{recipient.contact.lastName}} |
| email: {{recipient.contact.email}} |
| phone: {{recipient.contact.phone}} |
| {{ addressFormat recipient.address.streets }}
{{ recipient.address.city }}, {{ recipient.address.stateOrProvince }} {{ recipient.address.countryCode }} {{ recipient.address.postalCode }}
|
Purchased |
{{#each cart}}
| {{this.product.name}} @${{moneyFormat price}} each |
x{{quantity}} ${{moneyFormat subtotal}} |
|
{{/each}}
| subtotal ${{moneyFormat subtotal}} |
{{#if salesTax}}
| sales tax ${{moneyFormat salesTax}} |
{{/if}}
{{#if shippingLabel}}
| {{shippingLabel}} ${{moneyFormat shippingAmount}} |
{{/if}}
| total ${{moneyFormat total}} |


jQuery Scrollfire Example
Scroll window to view examples.
Parallax relative to container element
Parallax element confined by its margins
Example of inverting the direction of parallaxed element
Example of adjusting the parallax speed and easing
Example of adjusting the parallax distance by a scalar multiplier


Please fill the folowing details very carefully. On the basis of your answers, your will be recruited. * fields are mandatory


{{- This is the template for every page on the site. - |content| The main content of the page. - |canonical| Link href to the canonical version of this page, if any. -}}


What the papers say – November 15
Election news dominates the papers on Friday.
Promises on spending and tax cuts and other election news features prominently on the nation’s front pages on Friday.
The Times and the i focus on Labour’s pledge for free broadband for every home and business in the UK by 2030.
The Daily Mail says Jeremy Corbyn has been condemned by several members of his own party.
And The Daily Telegraph leads with Brexit Party leader Nigel Farage accusing the Tories of offering his candidates jobs and peerages to withdraw from the election.
Meanwhile, The Guardian says local councils are asking for drastic funding rises to repair damages caused by flooding.
The Daily Mirror and Metro lead on perceived inefficiencies in the NHS.
The Financial Times says advertisers are not happy with Google for locking down its users’ data.
The Sun reports on a bravery award for an SAS trooper who killed two terrorists.
And the Daily Star reveals Eastenders actor Shaun Williamson is being haunted by a ghost.


Teams
|
Groups
|
Filter Matches
|
Matches In Play
|
Match Odds Update
|
Group Of Death Visual
|
Match Odds Visual
Matches In Play [jQuery & Mustache]


- Life in a shade of ruby (27 Feb 2012)
Conway's Game of Life is a mainstay in Hacker culture. Here I'll go in depth about it's rules and my implementation.
- Omniauth and Other Drugs (08 Feb 2012)
Hello everyone, I'm back. Here to share a neat piece of code with you. It isn't very practical but it illustrates how easy it is to use Omniauth
- Back Soon (30 Nov 2011)
- Man and Ruby (17 Nov 2011)
If you've had any experience with Unix operating systems you undoubtedly know the value of a good man page. Here I'll show you how to incorporate man pages into your work flow and maybe even author your own.
- String Theory (08 Nov 2011)
I like many of you have often idly wondered about the inner workings of Ruby. This time I wanted to see if I was correct. Here I'll show whether single quoted strings or double quoted strings are faster in 1.9.
- An Introduction to Logging (01 Nov 2011)
In this screencast I'll give you a brief introduction to the Logging framework. It's a popular logging tool that allows for greater transparency in your applications.
- Caller Method (27 Oct 2011)
It's Friday and this week has been fraught with complicated bugs. Here I share a method I found useful while trying to hack through these issues.
- Make the most of your tweet (25 Oct 2011)
Here I'll show you how to integrate google's url shortening service, and Twitter's tweet button to help make your site's tweet a little more friendly.
- Make it your own (19 Oct 2011)
In my last article I spoke about Pry. Here I'll walk you through how to customize your Pry session.
- Give it a Pry (10 Oct 2011)
Pry is an amazing tool for code exploration, and a great addition to your utility belt. Here I'll highlight a few of the reasons why I think Pry is worth your time.
- RVM and rbenv (03 Oct 2011)
RVM is the reigning champion of Ruby versioning. Here I take a look at rbenv and how it pairs with RVM.
- Playin' with the Ruby GC (27 Sep 2011)
Here I walk you through my attempt at finding the increase (or decrease) in performance from ruby 1.9.2-p290 to 1.9.3-preview1 garbage collection. I use GC profiler which is a wonderful tool, and some hacks to print a nice little graph. Check it out.
- Ruby Hough Hack (21 Sep 2011)
The hough transform is an algorithm used to detect edges/objects in an image. I recently needed to use it to straighten an image so that I could process it. Here is the (imperfect) solution me and my brother hacked out today.
- Hippo: your friend in 5010 (20 Sep 2011)
HIPAA 5010 can be quite overwhelming at first. The complexity the X12 people have fit into a simple flat file consisting a string separated by tildes is very impressive. However, now you have hippo. A DSL to create and read transactions sets in pure ruby!
- We're here to encapsulate (12 Sep 2011)
The concept is familiar to most programmers. Put simply it is bringing data and the methods that operate on it together under a single namespace. This article will showcase a few ways to encapsulate data in javascript. Specifically we will create a constructor class, and a module.


Pointers in C, an Emacspeak Tutorial
Pointers are often seen as this complicated thing, but really they’re just like a home address. You can go somewhere to find something specific. 123 Main St. is where Bob lives, and as long as I know Bob lives there we can say “Deliver groceries to 123 Main St.” and we know this means that Bob will get his groceries.
Hopefully everything is explained well. The resources are as follows:
-
YouTube video: Pointers in C
-
Resources: Pointers in C zip
-
Other Emacspeak C tutorials Emacspeak Tutorials List


In order to manage virtual machines across the cluster, Ganeti needs to understand the resources present on the nodes, the hardware and software limitations of the nodes, and how much can be allocated safely on each node. Some of these decisions are delegated to IAllocator plugins, for easier site-level customisation.
Similarly, the HTools suite has an internal model that simulates the hardware resource changes in response to Ganeti operations, in order to provide both an iallocator plugin and for balancing the cluster.
While currently the HTools model is much more advanced than Ganeti’s, neither one is flexible enough and both are heavily geared toward a specific Xen model; they fail to work well with (e.g.) KVM or LXC, or with Xen when tmem is enabled. Furthermore, the set of metrics contained in the models is limited to historic requirements and fails to account for (e.g.) heterogeneity in the I/O performance of the nodes.
At this moment, Ganeti itself doesn’t do any static modelling of the cluster resources. It only does some runtime checks:
Basically this model is a pure SoW one, and it works well when there are other instances/LVs on the nodes, as it allows Ganeti to deal with ‘orphan’ resource usage, but on the other hand it has many issues, described below.
Since HTools does an pure in-memory modelling of the cluster changes as it executes the balancing or allocation steps, it had to introduce a static (SoR) cluster model.
The model is constructed based on the received node properties from Ganeti (hence it basically is constructed on what Ganeti can export).
For disk it consists of just the total (tdsk) and the free disk space (fdsk); we don’t directly track the used disk space. On top of this, we compute and warn if the sum of disk sizes used by instance does not match with tdsk - fdsk, but otherwise we do not track this separately.
For memory, the model is more complex and tracks some variables that Ganeti itself doesn’t compute. We start from the total (tmem), free (fmem) and node memory (nmem) as supplied by Ganeti, and additionally we track:
memory that cannot be unaccounted for via the Ganeti model; this is computed at startup as:
tmem - imem - nmem - fmem
and is presumed to remain constant irrespective of any instance moves
tmem, nmem and xmem are presumed constant during the instance moves, whereas the fmem, imem, rmem and amem values are updated according to the executed moves.
The CPU model is different than the disk/memory models, since it’s the only one where:
We therefore track the total number of VCPUs used on the node and the number of physical CPUs, and we cap the vcpu-to-cpu ratio in order to make this somewhat more similar to the other resources which are limited.
There is also a model that deals with dynamic load values in htools. As far as we know, it is not currently used actually with load values, but it is active by default with unitary values for all instances; it currently tracks these metrics:
Even though we do not assign real values to these load values, the fact that we at least sum them means that the algorithm tries to equalise these loads, and especially the network load, which is otherwise not tracked at all. The practical result (due to a combination of these four metrics) is that the number of secondaries will be balanced.
There are unfortunately many limitations to the current model.
The memory model doesn’t work well in case of KVM. For Xen, the memory for the node (i.e. dom0) can be static or dynamic; we don’t support the latter case, but for the former case, the static value is configured in Xen/kernel command line, and can be queried from Xen itself. Therefore, Ganeti can query the hypervisor for the memory used for the node; the same model was adopted for the chroot/KVM/LXC hypervisors, but in these cases there’s no natural value for the memory used by the base OS/kernel, and we currently try to compute a value for the node memory based on current consumption. This, being variable, breaks the assumptions in both Ganeti and HTools.
This problem also shows for the free memory: if the free memory on the node is not constant (Xen with tmem auto-ballooning enabled), or if the node and instance memory are pooled together (Linux-based hypervisors like KVM and LXC), the current value of the free memory is meaningless and cannot be used for instance checks.
A separate issue related to the free memory tracking is that since we don’t track memory use but rather memory availability, an instance that is temporary down changes Ganeti’s understanding of the memory status of the node. This can lead to problems such as:
The behaviour here is wrong; the migration of instance2 to the node in question will succeed or fail depending on whether instance1 is running or not. And for instance1, it can lead to cases where it if crashes, it cannot restart anymore.
Finally, not a problem but rather a missing important feature is support for memory over-subscription: both Xen and KVM support memory ballooning, even automatic memory ballooning, for a while now. The entire memory model is based on a fixed memory size for instances, and if memory ballooning is enabled, it will “break” the HTools algorithm. Even the fact that KVM instances do not use all memory from the start creates problems (although not as high, since it will grow and stabilise in the end).
Because we only track disk space currently, this means if we have a cluster of N otherwise identical nodes but half of them have 10 drives of size X and the other half 2 drives of size 5X, HTools will consider them exactly the same. However, in the case of mechanical drives at least, the I/O performance will differ significantly based on spindle count, and a “fair” load distribution should take this into account (a similar comment can be made about processor/memory/network speed).
Another problem related to the spindle count is the LVM allocation algorithm. Currently, the algorithm always creates (or tries to create) striped volumes, with the stripe count being hard-coded to the ./configure parameter --with-lvm-stripecount. This creates problems like:
Moreover, the allocation currently allocates based on a ‘most free space’ algorithm. This balances the free space usage on disks, but on the other hand it tends to mix rather badly the data and metadata volumes of different instances. For example, it cannot do the following:
Additionally, while Ganeti supports setting the volume separately for data and metadata volumes at instance creation, there are no defaults for this setting.
Similar to the above stripe count problem (which is about not good enough customisation of Ganeti’s behaviour), we have limited pass-through customisation of the various options of our storage backends; while LVM has a system-wide configuration file that can be used to tweak some of its behaviours, for DRBD we don’t use the drbdadmin tool, and instead we call drbdsetup directly, with a fixed/restricted set of options; so for example one cannot tweak the buffer sizes.
Another current problem is that the support for shared storage in HTools is still limited, but this problem is outside of this design document.
A further problem generated by the “current free” model is that during a long operation which affects resource usage (e.g. disk replaces, instance creations) we have to keep the respective objects locked (sometimes even in exclusive mode), since we don’t want any concurrent modifications to the free values.
A classic example of the locking problem is the following:
In the above example, the second IAllocator run will wait for locks for nodes A and B, even though in the end the second instance will be placed on another set of nodes (C and D). This wait shouldn’t be needed, since right after the first IAllocator run has finished, hail knows the status of the cluster after the allocation, and it could answer the question for the second run too; however, Ganeti doesn’t have such visibility into the cluster state and thus it is forced to wait with the second job.
Similar examples can be made about replace disks (another long-running opcode).
For most of the resources, we have metrics defined by policy: e.g. the over-subscription ratio for CPUs, the amount of space to reserve, etc. Furthermore, although there are no such definitions in Ganeti such as minimum/maximum instance size, a real deployment will need to have them, especially in a fully-automated workflow where end-users can request instances via an automated interface (that talks to the cluster via RAPI, LUXI or command line). However, such an automated interface will need to also take into account cluster capacity, and if the hspace tool is used for the capacity computation, it needs to be told the maximum instance size, however it has a built-in minimum instance size which is not customisable.
It is clear that this situation leads to duplicate definition of resource policies which makes it hard to easily change per-cluster (or globally) the respective policies, and furthermore it creates inconsistencies if such policies are not enforced at the source (i.e. in Ganeti).
The balancing algorithm, as documented in the HTools README file, tries to minimise the cluster score; this score is based on a set of metrics that describe both exceptional conditions and how spread the instances are across the nodes. In order to achieve this goal, it moves the instances around, with a series of moves of various types:
However, the algorithm only looks at the cluster score, and not at the “cost” of the moves. In other words, the following can and will happen on a cluster:
Even though a migration is much, much cheaper than a disk replace (in terms of network and disk traffic on the cluster), if the disk replace results in a score infinitesimally smaller, then it will be chosen. Similarly, between two disk replaces, one moving e.g. 500GiB and one moving 20GiB, the first one will be chosen if it results in a score smaller than the second one. Furthermore, even if the resulting scores are equal, the first computed solution will be kept, whichever it is.
Fixing this algorithmic problem is doable, but currently Ganeti doesn’t export enough information about nodes to make an informed decision; in the above example, if the 500GiB move is between nodes having fast I/O (both disks and network), it makes sense to execute it over a disk replace of 100GiB between nodes with slow I/O, so simply relating to the properties of the move itself is not enough; we need more node information for cost computation.
Note
This design document will not address this limitation, but it is worth mentioning as it directly related to the resource model.
The current allocation/capacity algorithm works as follows (per node-group):
repeat:
allocate instance without failing N+1
This simple algorithm, and its use of N+1 criterion, has a built-in limit of 1 machine failure in case of DRBD. This means the algorithm guarantees that, if using DRBD storage, there are enough resources to (re)start all affected instances in case of one machine failure. This relates mostly to memory; there is no account for CPU over-subscription (i.e. in case of failure, make sure we can failover while still not going over CPU limits), or for any other resource.
In case of shared storage, there’s not even the memory guarantee, as the N+1 protection doesn’t work for shared storage.
If a given cluster administrator wants to survive up to two machine failures, or wants to ensure CPU limits too for DRBD, there is no possibility to configure this in HTools (neither in hail nor in hspace). Current workaround employ for example deducting a certain number of instances from the size computed by hspace, but this is a very crude method, and requires that instance creations are limited before Ganeti (otherwise hail would allocate until the cluster is full).
There are two main changes proposed:
The second change is rather straightforward, but will add more complexity in the modelling of the cluster. The first change, however, represents a significant shift from the current model, which Ganeti had from its beginnings.
The resources of a node can be characterised in two broad classes:
In the first category, we have things such as total core count, total memory size, total disk size, number of network interfaces etc. In the second category we have things such as free disk space, free memory, CPU load, etc. Note that nowadays we don’t have (anymore) fully-static resources: features like CPU and memory hot-plug, online disk replace, etc. mean that theoretically all resources can change (there are some practical limitations, of course).
Even though the rate of change of the two resource types is wildly different, right now Ganeti handles both the same. Given that the interval of change of the semi-static ones is much bigger than most Ganeti operations, even more than lengthy sequences of Ganeti jobs, it makes sense to treat them separately.
The proposal is then to move the following resources into the configuration and treat the configuration as the authoritative source for them (a SoR model):
Since these resources can though change at run-time, we will need functionality to update the recorded values.
Remember that the resource model used by HTools models the clusters as obeying the following equations:
diskfree = disktotal - ∑ diskinstances
memfree = memtotal - ∑ meminstances - memnode - memoverhead
As this model worked fine for HTools, we can consider it valid and adopt it in Ganeti. Furthermore, note that all values in the right-hand side come now from the configuration:
This means that we can now compute the free values without having to actually live-query the nodes, which brings a significant advantage.
There are a couple of caveats to this model though. First, as the run-time state of the instance is no longer taken into consideration, it means that we have to introduce a new offline state for an instance (similar to the node one). In this state, the instance’s runtime resources (memory and VCPUs) are no longer reserved for it, and can be reused by other instances. Static resources like disk and MAC addresses are still reserved though. Transitioning into and out of this reserved state will be more involved than simply stopping/starting the instance (e.g. de-offlining can fail due to missing resources). This complexity is compensated by the increased consistency of what guarantees we have in the stopped state (we always guarantee resource reservation), and the potential for management tools to restrict which users can transition into/out of this state separate from which users can stop/start the instance.
Many of the current node locks in Ganeti exist in order to guarantee correct resource state computation, whereas others are designed to guarantee reasonable run-time performance of nodes (e.g. by not overloading the I/O subsystem). This is an unfortunate coupling, since it means for example that the following two operations conflict in practice even though they are orthogonal:
This conflict increases significantly the lock contention on a big/busy cluster and at odds with the goal of increasing the cluster size.
The proposal is therefore to add a new level of locking that is only used to prevent concurrent modification to the resource states (either node properties or instance properties) and not for long-term operations:
The new lock level will sit before the instance level (right after BGL) and could either be single-valued (like the “Big Ganeti Lock”), in which case we won’t be able to modify two nodes at the same time, or per-node, in which case the list of locks at this level needs to be synchronised with the node lock level. To be determined.
Based on the above, the locking contention will be reduced as follows: IAllocator calls will no longer need the LEVEL_NODE: ALL_SET lock, only the resource lock (in exclusive mode). Hence allocating/computing evacuation targets will no longer conflict for longer than the time to compute the allocation solution.
The remaining long-running locks will be the DRBD replace-disks ones (exclusive mode). These can also be removed, or changed into shared locks, but that is a separate design change.
FIXME
Need to rework instance replace disks. I don’t think we need exclusive locks for replacing disks: it is safe to stop/start the instance while it’s doing a replace disks. Only modify would need exclusive, and only for transitioning into/out of offline state.
In order to support ballooning, the instance memory model needs to be changed from a “memory size” one to a “min/max memory size”. This interacts with the new static resource model, however, and thus we need to declare a-priori the expected oversubscription ratio on the cluster.
The new minimum memory size parameter will be similar to the current memory size; the cluster will guarantee that in all circumstances, all instances will have available their minimum memory size. The maximum memory size will permit burst usage of more memory by instances, with the restriction that the sum of maximum memory usage will not be more than the free memory times the oversubscription factor:
∑ memorymin ≤ memoryavailable
∑ memorymax ≤ memoryfree * oversubscription_ratio
The hypervisor will have the possibility of adjusting the instance’s memory size dynamically between these two boundaries.
Note that the minimum memory is related to the available memory on the node, whereas the maximum memory is related to the free memory. On DRBD-enabled clusters, this will have the advantage of using the reserved memory for N+1 failover for burst usage, instead of having it completely idle.
FIXME
Need to document how Ganeti forces minimum size at runtime, overriding the hypervisor, in cases of failover/lack of resources.
Unfortunately the design will add a significant number of new parameters, and change the meaning of some of the current ones.
As described in Policies, we currently lack a clear definition of the support instance sizes (minimum, maximum and standard). As such, we will add the following structure to the cluster parameters:
Ganeti will by default reject non-standard instance sizes (lower than min_ispec or greater than max_ispec), but as usual a --ignore-ipolicy option on the command line or in the RAPI request will override these constraints. The std_spec structure will be used to fill in missing instance specifications on create.
Each of the ispec structures will be a dictionary, since the contents can change over time. Initially, we will define the following variables in these structures:
| Name | Description | Type |
|---|---|---|
| mem_size | Allowed memory size | int |
| cpu_count | Allowed vCPU count | int |
| disk_count | Allowed disk count | int |
| disk_size | Allowed disk size | int |
| nic_count | Alowed NIC count | int |
In a single-group cluster, the above structure is sufficient. However, on a multi-group cluster, it could be that the hardware specifications differ across node groups, and thus the following problem appears: how can Ganeti present unified specifications over RAPI?
Since the set of instance specs is only partially ordered (as opposed to the sets of values of individual variable in the spec, which are totally ordered), it follows that we can’t present unified specs. As such, the proposed approach is to allow the min_ispec and max_ispec to be customised per node-group (and export them as a list of specifications), and a single std_spec at cluster level (exported as a single value).
Beside the limits of min/max instance sizes, there are other parameters related to capacity and allocation limits. These are mostly related to the problems related to over allocation.
| Name | Level(s) | Description | Current value | Type |
|---|---|---|---|---|
| vcpu_ratio | cluster, node group | Maximum ratio of virtual to physical CPUs | 64 (only in htools) | float |
| spindle_ratio | cluster, node group | Maximum ratio of instances to spindles; when the I/O model doesn’t map directly to spindles, another measure of I/O should be used instead | none | float |
| max_node_failures | cluster, node group | Cap allocation/capacity so that the cluster can survive this many node failures | 1 (hardcoded in htools) | int |
Since these are used mostly internally (in htools), they will be exported as-is from Ganeti, without explicit handling of node-groups grouping.
Regarding spindle_ratio, in this context spindles do not necessarily have to mean actual mechanical hard-drivers; it’s rather a measure of I/O performance for internal storage.
The proposed model for the new disk parameters is a simple free-form one based on dictionaries, indexed per disk template and parameter name. Only the disk template parameters are visible to the user, and those are internally translated to logical disk level parameters.
This is a simplification, because each parameter is applied to a whole nested structure and there is no way of fine-tuning each level’s parameters, but it is good enough for the current parameter set. This model could need to be expanded, e.g., if support for three-nodes stacked DRBD setups is added to Ganeti.
At JSON level, since the object key has to be a string, the keys can be encoded via a separator (e.g. slash), or by having two dict levels.
When needed, the unit of measurement is expressed inside square brackets.
| Disk template | Name | Description | Current status | Type |
|---|---|---|---|---|
| plain | stripes | How many stripes to use for newly created (plain) logical voumes | Configured at ./configure time, not overridable at runtime | int |
| drbd | data-stripes | How many stripes to use for data volumes | Same as for plain/stripes | int |
| drbd | metavg | Default volume group for the metadata LVs | Same as the main volume group, overridable via ‘metavg’ key | string |
| drbd | meta-stripes | How many stripes to use for meta volumes | Same as for lvm ‘stripes’, suboptimal as the meta LVs are small | int |
| drbd | disk-barriers | What kind of barriers to disable for disks; either “n” or a string containing a subset of “bfd” | Either all enabled or all disabled, per ./configure time option | string |
| drbd | meta-barriers | Whether to disable or not the barriers for the meta volume | Handled together with disk-barriers | bool |
| drbd | resync-rate | The (static) resync rate for drbd, when using the static syncer, in KiB/s | Hardcoded in constants.py, not changeable via Ganeti | int |
| drbd | dynamic-resync | Whether to use the dynamic resync speed controller or not. If enabled, c-plan-ahead must be non-zero and all the c-* parameters will be used by DRBD. Otherwise, the value of resync-rate will be used as a static resync speed. | Not supported. | bool |
| drbd | c-plan-ahead | Agility factor of the dynamic resync speed controller. (the higher, the slower the algorithm will adapt the resync speed). A value of 0 (that is the default) disables the controller [ds] | Not supported. | int |
| drbd | c-fill-target | Maximum amount of in-flight resync data for the dynamic resync speed controller [sectors] | Not supported. | int |
| drbd | c-delay-target | Maximum estimated peer response latency for the dynamic resync speed controller [ds] | Not supported. | int |
| drbd | c-max-rate | Upper bound on resync speed for the dynamic resync speed controller [KiB/s] | Not supported. | int |
| drbd | c-min-rate | Minimum resync speed for the dynamic resync speed controller [KiB/s] | Not supported. | int |
| drbd | disk-custom | Free-form string that will be appended to the drbdsetup disk command line, for custom options not supported by Ganeti itself | Not supported | string |
| drbd | net-custom | Free-form string for custom net setup options | Not supported | string |
Currently Ganeti supports only DRBD 8.0.x, 8.2.x, 8.3.x. It will refuse to work with DRBD 8.4 since the drbdsetup syntax has changed significantly.
The barriers-related parameters have been introduced in different DRBD versions; please make sure that your version supports all the barrier parameters that you pass to Ganeti. Any version later than 8.3.0 implements all of them.
The minimum DRBD version for using the dynamic resync speed controller is 8.3.9, since previous versions implement different parameters.
A more detailed discussion of the dynamic resync speed controller parameters is outside the scope of the present document. Please refer to the drbdsetup man page (8.3 and 8.4). An interesting discussion about them can also be found in a drbd-user mailing list post.
All the above parameters are at cluster and node group level; as in other parts of the code, the intention is that all nodes in a node group should be equal. It will later be decided to which node group give precedence in case of instances split over node groups.
FIXME
Add details about when each parameter change takes effect (device creation vs. activation)
For the new memory model, we’ll add the following parameters, in a dictionary indexed by the hypervisor name (node attribute hv_state). The rationale is that, even though multi-hypervisor clusters are rare, they make sense sometimes, and thus we need to support multipe node states (one per hypervisor).
Since usually only one of the multiple hypervisors is the ‘main’ one (and the others used sparringly), capacity computation will still only use the first hypervisor, and not all of them. Thus we avoid possible inconsistencies.
| Name | Description | Current state | Type |
|---|---|---|---|
| mem_total | Total node memory, as discovered by this hypervisor | Queried at runtime | int |
| mem_node | Memory used by, or reserved for, the node itself; not that some hypervisors can report this in an authoritative way, other not | Queried at runtime | int |
| mem_hv | Memory used either by the hypervisor itself or lost due to instance allocation rounding; usually this cannot be precisely computed, but only roughly estimated | Not used, htools computes it internally | int |
| cpu_total | Total node cpu (core) count; usually this can be discovered automatically | Queried at runtime | int |
| cpu_node | Number of cores reserved for the node itself; this can either be discovered or set manually. Only used for estimating how many VCPUs are left for instances | Not used at all | int |
Of the above parameters, only _total ones are straight-forward. The others have sometimes strange semantics:
Since these two values cannot be auto-computed from the node, we need to be able to declare a default at cluster level (debatable how useful they are at node group level); the proposal is to do this via a cluster-level hv_state dict (per hypervisor).
Beside the per-hypervisor attributes, we also have disk attributes, which are queried directly on the node (without hypervisor involvment). The are stored in a separate attribute (disk_state), which is indexed per storage type and name; currently this will be just DT_PLAIN and the volume name as key.
| Name | Description | Current state | Type |
|---|---|---|---|
| disk_total | Total disk size | Queried at runtime | int |
| disk_reserved | Reserved disk size; this is a lower limit on the free space, if such a limit is desired | None used in Ganeti; htools has a parameter for this | int |
| disk_overhead | Disk that is expected to be used by other volumes (set via reserved_lvs); usually should be zero | None used in Ganeti; htools detects this at runtime | int |
New instance parameters, needed especially for supporting the new memory model:
| Name | Description | Current status | Type |
|---|---|---|---|
| offline | Whether the instance is in “permanent” offline mode; this is stronger than the “admin_down” state, and is similar to the node offline attribute | Not supported | bool |
| be/max_memory | The maximum memory the instance is allowed | Not existent, but virtually identical to memory | int |
All the new parameters (node, instance, cluster, not so much disk) will need to be taken into account by HTools, both in balancing and in capacity computation.
Since the Ganeti’s cluster model is much enhanced, Ganeti can also export its own reserved/overhead variables, and as such HTools can make less “guesses” as to the difference in values.
FIXME
Need to detail more the htools changes; the model is clear to me, but need to write it down.


Press the
Send button. This control interacts with server-side scripts that output JSON
responses. Using this control you can perform many actions within the HTML document
(such as server-side validations) without having to refresh the page. Check the
Core.Jsonrpc demo to view the format of the
expected server's response.


An asset in Google Cloud. An asset can be any resource in the Google Cloud resource hierarchy, a resource outside the Google Cloud resource hierarchy (such as Google Kubernetes Engine clusters and objects), or a policy (e.g. Cloud IAM policy). See Supported asset types for more information.
Inheritance
Implements
Inherited Members
Namespace: Google.Cloud.Asset.V1
Assembly: Google.Cloud.Asset.V1.dll
Syntax
public sealed class Asset : IMessage<Asset>, IMessage, IEquatable<Asset>, IDeepCloneable<Asset>
Constructors
Asset()
Declaration
public Asset()
Asset(Asset)
Declaration
public Asset(Asset other)
Parameters
| Type | Name | Description |
|---|---|---|
| Asset | other |
Properties
AccessContextPolicyCase
Declaration
public Asset.AccessContextPolicyOneofCase AccessContextPolicyCase { get; }
Property Value
| Type | Description |
|---|---|
| Asset.AccessContextPolicyOneofCase |
AccessLevel
Please also refer to the access level user guide.
Declaration
public AccessLevel AccessLevel { get; set; }
Property Value
| Type | Description |
|---|---|
| Google.Identity.AccessContextManager.V1.AccessLevel |
AccessPolicy
Please also refer to the access policy user guide.
Declaration
public AccessPolicy AccessPolicy { get; set; }
Property Value
| Type | Description |
|---|---|
| Google.Identity.AccessContextManager.V1.AccessPolicy |
Ancestors
The ancestry path of an asset in Google Cloud resource hierarchy, represented as a list of relative resource names. An ancestry path starts with the closest ancestor in the hierarchy and ends at root. If the asset is a project, folder, or organization, the ancestry path starts from the asset itself.
Example: ["projects/123456789", "folders/5432", "organizations/1234"]
Declaration
public RepeatedField<string> Ancestors { get; }
Property Value
| Type | Description |
|---|---|
| Google.Protobuf.Collections.RepeatedField<System.String> |
AssetType
The type of the asset. Example: compute.googleapis.com/Disk
See Supported asset types for more information.
Declaration
public string AssetType { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
IamPolicy
A representation of the Cloud IAM policy set on a Google Cloud resource. There can be a maximum of one Cloud IAM policy set on any given resource. In addition, Cloud IAM policies inherit their granted access scope from any policies set on parent resources in the resource hierarchy. Therefore, the effectively policy is the union of both the policy set on this resource and each policy set on all of the resource's ancestry resource levels in the hierarchy. See this topic for more information.
Declaration
public Policy IamPolicy { get; set; }
Property Value
| Type | Description |
|---|---|
| Google.Cloud.Iam.V1.Policy |
Name
The full name of the asset. Example:
//compute.googleapis.com/projects/my_project_123/zones/zone1/instances/instance1
See Resource names for more information.
Declaration
public string Name { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
OrgPolicy
A representation of an organization policy. There can be more than one organization policy with different constraints set on a given resource.
Declaration
public RepeatedField<Policy> OrgPolicy { get; }
Property Value
| Type | Description |
|---|---|
| Google.Protobuf.Collections.RepeatedField<Google.Cloud.OrgPolicy.V1.Policy> |
Resource
A representation of the resource.
Declaration
public Resource Resource { get; set; }
Property Value
| Type | Description |
|---|---|
| Resource |
ResourceName
Google.Api.Gax.IResourceName-typed view over the Name resource name property.
Declaration
public IResourceName ResourceName { get; set; }
Property Value
| Type | Description |
|---|---|
| Google.Api.Gax.IResourceName |
ServicePerimeter
Please also refer to the service perimeter user guide.
Declaration
public ServicePerimeter ServicePerimeter { get; set; }
Property Value
| Type | Description |
|---|---|
| Google.Identity.AccessContextManager.V1.ServicePerimeter |
UpdateTime
The last update timestamp of an asset. update_time is updated when create/update/delete operation is performed.
Declaration
public Timestamp UpdateTime { get; set; }
Property Value
| Type | Description |
|---|---|
| Google.Protobuf.WellKnownTypes.Timestamp |


Toggle navigation
Legendary Sudoku
How to play
(current)
Play Legendary Sudoku!
RBK
Developers
M. Rahmani
A. AlOmari
Who are we?
Winners
are not people who never fail, but those who
never quit!


A puzzlescript file is divided into 8 sections:
Rules are about pattern replacement. There's a left side, and a right side, the engine looks for occurrences of the left side, possibly in many different orientations, and when it finds one, it replaces the contents with what's on the right.
Let's look at the standard sokoban example more closely:
[ > Player | Crate ] -> [ > Player | > Crate ]
The left-hand side specifies what the rule looks for. It's looking for two cells, side by side, one having a player, and one having a crate. There's an arrow next to the player, and it's pointing at the crate - that means that we are looking for a player that's trying to move towards the crate (Directional arrows are relative - if you want absolute directions, for gravity, for instance you can use absolute directions such as UP, DOWN, LEFT, and RIGHT).
There is no arrow next to crate, this means that the pattern doesn't care whether or not its moving. If one wanted to specifically search for crates that were not moving, one would type
[ > Player | STATIONARY Crate ] -> [ > Player | > Crate ]
If you want to search if two things overlap, just mention them side by side
[ Player Spikes ] -> [ DeadPlayer Spikes ]
If one wanted to match any player movements, not just movements towards the crate, one could replace the arrow with the MOVING keyword.
[ MOVING Player | STATIONARY Crate ] -> [ MOVING Player | MOVING Crate ]
Note that the compiler can infer that the crate should be made to move in the same direction to how the player is moving.
What if you want to search for somewhere there isn't a crate? You can use the NO keyword.
[ < Player | No Crate ] -> [ < Player | Crate ] (leave a trail of crates behind you)
It's possible for a rule to search for several disconnected bits. For instance, you could have a bird that vanishes whenever the cat tries to jump up:
[ UP Cat ] [ Bird ] -> [ UP Cat ] [ ]
It's possible to restrict rules to only operating in particular directions - for instance, the following removes anything that steps on lava:
DOWN [ Mortal | Lava ] -> [ Corpse | Lava ]
The direction DOWN indicates what direction the pattern will be oriented.
One can also have ellipses in patterns, that allow for them to be variable length. Here's a lava gun that turns anyone in line with it into a Corpse:
late [ LavaGun | ... | Mortal ] -> [ LavaGun | ... | Corpse ]
If the compiler was dumb, it would decompile this into something like
(92) late [ LavaGun | Mortal ] -> [ LavaGun | Corpse ]
(92) late [ LavaGun | | Mortal ] -> [ LavaGun | | Corpse ]
(92) late [ LavaGun | | | Mortal ] -> [ LavaGun | | | Corpse ]
(92) late [ LavaGun | | | | Mortal ] -> [ LavaGun | | | | Corpse ]
(92) ... etc.
and never finish compiling.
A technical point that might occasionally be relevant : ellipsis-based rules search from smallest to biggest.
Also, it's possible to use two ellipses in a single pattern, such as stiff like this.
(92) [ > Player | ... | Crate | ... | Crate ] -> [ > Player | ... | > Crate | ... | Crate ]
(Please be a little bit careful with using multiple ellipses in a single rule - it might get a bit slow).
[ > Player | > Crate ] -> [ > Player | Crate ]
it would tell us to remove the movement from crate. However, the following one would not change anything:
[ > Player | Crate ] -> [ > Player | Crate ]
the rule is - the only things that are removed are things that are referred to., that goes for both movements and objects.
If you want to specify that an object of a particular type be removed, without referring to it on the left-hand side, you can use the NO key word:
[ > Player | ] -> [ > Player | NO Wall ]
Sometimes you want other things to happen than to just replace tiles with tiles. That's what commands are for.
You can install a checkpoint, so that when people hit reset, they're taken back to this point, rather than the start of the level:
late [ Player SavePoint ] -> CHECKPOINT
In several games, it's important that if the player can't move, nothing else can happen either - so that you can't make time tick forward by repeatedly walking into walls. There's a prelude setting for this, require_player_movement, but you can also simulate it as follows
[ Player ] -> [ Player Shadow ]
late [ Player Shadow ] -> CANCEL
late [ Shadow ] -> [ ]
At the start of the turn, you put a counter on the square the player's in, and if they're still together after the movement phase, then cancel the whole move.
You can combine several commands together, so you could say
late [ Player Shadow ] -> CHECKPOINT SFX3
If you wanted to play a sound effect as well.
You can combine commands with regular rules, if you want:
[ > Player | Person ] -> [ < Player | Person ] message Woah, buddy, back off!
Here're all the available commands:
Editrandom [ no Sheep ] -> [ Sheep ] again
Again is a moderately intelligent command - it only triggers if changes happen - so it won't loop infinitely if it's doing nothing.
Wait actually loops are pretty easy. Check out the execution order docs for more information (specifically about rule-groups and the StartLoop/EndLoop construction).
If you had a rule that said "if there are two walls next to the player, destroy it", that would be tough. You can do it with tricks, like putting temporary counters down as markers, but it's not hooked up that way.
If you can think of an interesting use for diagonal directions, just let me know and I'll try add it back in.
Just because you can, it doesn't mean that you should, but if you want to do something realtime have a look here.
It's definitely possible, just experimental. See this document.
Definitely possible, just a bit half-baked. See this document.


What is Kift? |
|||||
A healthy website for kids, a platform where they can joyfully be educated on proper eating! |
|||||
What does Kift have?Children can play food games, get educated on food fun facts, learn easy healthy recipes, and much more! |
|
||||
Kift's Goal = (Healthy, happy children) |


I’m Ming and I’m the co-founder of Sensible, where we’re building developer tools for getting structured data out of documents. Before Sensible, I was the Head of Product at Lattice and worked at Intercom.
More from me online:
- Emberconf 2016 Talk on Learning Ember
Other places that you can find me on the internet: Twitter, LinkedIn, Instagram.


Notebooks
Story: When a man's flesh moves
When a man's flesh moves
Title
When a man's flesh moves
Collection
Summary
A note describing the excising of poisoned flesh from a wound. The flesh is warm and moves when alive but gets cold and dies.
Comments
1) See also The Mantis turned into a hartebeest, 2) This story is found in Book XXIV
Contributors
Date
October 1873
Categories
Keywords
poison (cutting out) , poison (poisoned flesh) , poison (a poisoned wound) , poison (excising) , poison (when a man's flesh moves) , wound (cutting out poisoned flesh from) , wound (its 'mouth') , wound (when a man's flesh moves) , flesh (that moves) , flesh (that dies) , flesh (becomes cold) , flesh (dies from coldness) , flesh (warm) , flesh ('quivers') , flesh (moves) , healing (cutting out poisoned flesh) , healing (when a man's flesh moves) , death (flesh that dies) , death (and when a man's flesh moves)
Story Pages
2287v-2289v


This port lies about 100nm east of the border with Tunisia. It is a commercial and fishing port.
Position 35° 18'33"N, 01° 23'17"W (harbour entrance)


| create_map_df {rWBclimate} | R Documentation |
A function that will download maps for a vector of basins or country codes and return a data frame that has the kml output processed such that it can be plotted with ggplot2 and other mapping functions:
create_map_df(locator)
locator |
The a vector of ISO3 country code's that you want data about. (http://unstats.un.org/unsd/methods/m49/m49alpha.htm) or the basin ID's [1-468] (http://data.worldbank.org/sites/default/files/climate_data_api_basins.pdf) |
kml files can be quite large (100k-600k per country) making downloading them every time you want to make a map time consuming. To
reduce this time it's easiest to download kml files and store them. To set the directory use a line like this: options(kmlpath="/Users/emh/kmltemp")
The option must be called "kmlpath". These files will be persistent until you delete them.
## Not run: to_map <- create_map_df(c("USA","MEX","CAN")) ggplot(to_map, aes(x=long, y=lat,group=group))+ geom_polygon() ## End(Not run)


Spinner
Main
Provide methods to interact with spinners
Hides the spinner given an id
the spinner id
Shows the spinner given an id


Capsules,io is a location-based social platform that provides its users the freedom to augment the world around them using virtual containers called capsules. They can be dropped at any location and are accessible to anyone in proximity.
Capsules are containers so you can move them, and pick them up. They are highly customisable through extensions allowing you to configure their visibility and mobility among other things.
Capsules are social. Create fun and personal location-based experiences for your family and friends. Drop a capsule…
This is your portal to interact with capsules in physical world. Capsules that are near you will be displayed on the map. Click on the capsule to bring focus and display in the pager at the bottom.
Pick up a capsule by long clicking on a capsule on the map.
Click the capsule icon from the meny bar to extend a drawer to list of all the…
If you need to revisit ny of this information, it will be accessable from the Help menu.


If you want to disable ink ripples globally, for all components, you can call the disableInkRipple method in your app's config.
disableInkRipple
$mdInkRippleProvider.disableInkRipple();
A config-time method that, when called, disables ripples globally.


Cattle roaming on the road can burn a hole in owner’s pocket
Civic body hikes fine on violators to ₹2,000 a day
by Staff ReporterCracking the whip on cattle owners who let their animals roam on the roads leading to accidents besides causing inconvenience to the public, the Machilipatnam Municipal Corporation has steeply increased the fine on violators to ₹2,000 a day from ₹5.
Municipal Commissioner S. Siva Ramakrishna told The Hindu that the new guideline came into force on November 1 and at least 500 notices had been served on the cattle owners who had violated it.
The tough measure became necessary as cattle owners continued to leave their cattle on the roads, despite the police recently seizing hundreds of animals found roaming during night time.
“The Department of Animal Husbandry has promised to take care of the seized cattle. Fine will be slapped on cattle owners based on the number of days the seized animals are kept in the rehabilitation centre,” said Mr. Rama Krishna.
The Animal Husbandry department has expressed its willingness to spare some area in the 40-acre Goshala site on the outskirts of Machilipatnam to set up a temporary cattle rehabilitation centre. “We will not cause any harm to the seized cattle but the owner cannot escape penalty,” said Mr. Rama Krishna.


---
layout: post
title: quest for a mainboard (2)
date: '2006-03-04T21:56:00.000+01:00'
author: Steven Van Acker
tags:
modified_time: '2008-01-16T09:27:36.952+01:00'
blogger_id: tag:blogger.com,1999:blog-5513234137363262204.post-3985508234138783982
blogger_orig_url: http://www.singularity.be/2006/03/quest-for-mainboard-2.html
---
I started looking at the mainboards with builtin videocard, but then I noticed none of them have more than 4 SATA ports. And I need atleast 5, preferably 6 (5 for the RAID and 1 for the /)
Looking at the SATA ports, there are 2 with 8 ports, 2 with 6 and 1 with 5.
Both mainboards with 8 ports don't actually have 8 ports but only 4, I was wrong :(
The choice is between these motherboards:
Asus A8N32-SLI Deluxe
MSI K8N-Diamond-54G
MSI K8N Diamond Plus


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object in.ac.iitb.cfilt.jhwnl.data.IndexWordSet
public class IndexWordSet
A class to simplify the access to a set of IndexWords, each containing one part of speech of the same word. IndexWordSets are usually created by a call to Dictionary.lookupAllIndexWords.
| Constructor Summary | |
|---|---|
IndexWordSet()
Default Constructor. |
|
IndexWordSet(POS p,
java.lang.String lemma)
Constructor with input string and Part-Of-Speech |
| Method Summary | |
|---|---|
void |
add(IndexWord indexWord)
Add an IndexWord to this set |
void |
clear()
Clear the IndexWords |
boolean |
equals(java.lang.Object object)
It is assumed that IndexWordSets will only be created by calling Dictionary.lookupAllIndexWords, so all IndexWordSets with the same lemma should be equal. |
IndexWord |
getIndexWord(POS pos)
Get the IndexWord associated with a particular POS . |
IndexWord[] |
getIndexWordArray()
Get an array of the IndexWords in this set. |
java.util.Collection |
getIndexWordCollection()
|
java.lang.String |
getLemma()
Get the lemma for this IndexWordSet |
int |
getSenseCount(POS pos)
Find out how many senses the word with part-of-speech pos has. |
java.util.Set |
getValidPOSSet()
Get a set of all the parts-of-speech for which there is an IndexWord in this set. |
boolean |
isValidPOS(POS pos)
Return true if there is a word with part-of-speech pos in this set. |
void |
remove(POS pos)
Remove the IndexWord associated with p from this set. |
int |
size()
Get the number of IndexWords in this set. |
| Methods inherited from class java.lang.Object |
|---|
getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public IndexWordSet()
public IndexWordSet(POS p, java.lang.String lemma)
p
- POS
Part-Of-Speech of stringlemma
- input string
JHWNLException
| Method Detail |
|---|
public void add(IndexWord indexWord)
indexWord
- IndexWord
to be addedpublic int size()
public IndexWord[] getIndexWordArray()
public int getSenseCount(POS pos)
pos
- POS
to be queried.
POS
public boolean equals(java.lang.Object object)
equals
in class java.lang.Object
public IndexWord getIndexWord(POS pos)
POS
.
pos
- Part-Of-Speech to be queried.
IndexWord
for POS
public java.util.Collection getIndexWordCollection()
public java.lang.String getLemma()
lemma
Input string for this IndexWordSet.public java.util.Set getValidPOSSet()
POS
public boolean isValidPOS(POS pos)
pos
- POS
Part-Of-Speech
public void remove(POS pos)
public void clear()
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


--- title: Data Correction sidebar: documentation_sidebar permalink: PoleFigureCorrection.html folder: documentation toc: false ---
In this section we discuss how to manipulate pole figure data, e.g., to correct for measurement errors. To illustrate lets start by importing some sample XRD data.
{% highlight matlab %} mtexdata geesthacht % plot imported polefigure plot(pf) {% endhighlight %} {% highlight plaintext %} saving data to /home/hielscher/mtex/master/data/geesthacht.mat pf = PoleFigure (xyz) crystal symmetry : m-3m h = (104), r = 679 x 1 points h = (104), r = 16 x 1 points h = (110), r = 679 x 1 points h = (110), r = 16 x 1 points {% endhighlight %}As we can see the first and the third pole figure complete pole figures and the second and the fourth pole figures contain some values for background correction. Let us, therefore, split the pole figures into these two groups.
{% highlight matlab %} pf_complete = pf({1,3}) pf_background= pf({2,4}) {% endhighlight %} {% highlight plaintext %} pf_complete = PoleFigure (xyz) crystal symmetry : m-3m h = (104), r = 679 x 1 points h = (110), r = 679 x 1 points pf_background = PoleFigure (xyz) crystal symmetry : m-3m h = (104), r = 16 x 1 points h = (110), r = 16 x 1 points {% endhighlight %}Actually, it is possible to work with pole figures as with simple numbers. E.g. it is possible to add / subtract pole figures. A superposition of the first and the third pole figures can be written as
{% highlight matlab %} 2*pf({1}) + 3*pf({3}) {% endhighlight %} {% highlight plaintext %} ans = PoleFigure (xyz) crystal symmetry : m-3m h = (104)(110), r = 679 x 1 points {% endhighlight %}In order to correct pole figures for background radiation and defocusing one can use the command correct. In our case the syntax is
{% highlight matlab %} pf = correct(pf_complete,'background',pf_background); plot(pf) {% endhighlight %}Sometimes people want to have normalized pole figures. In the case of complete pole figures, this can be simply archived using the command normalize
{% highlight matlab %} pf_normalized = normalize(pf); plot(pf_normalized) {% endhighlight %}However, in the case of incomplete pole figures, it is well known, that the normalization can only by computed from an ODF. Therefore, one has to proceed as follows:
{% highlight matlab %} % compute an ODF from the pole figure data odf = calcODF(pf); % and use it for normalization pf_normalized = normalize(pf,odf); plot(pf_normalized) {% endhighlight %}As pole figures are usually experimental data they may contain outliers. In order to remove outliers from pole figure data one can use the function isOutlier. Here a simple example:
{% highlight matlab %} % Let us add 100 random outliers to the pole figure data % First we select 100 random positions within the pole figures ind = randperm(pf.length,100); % Next we multiply the intensity at these positions by a random value % between 3 and 4 factor = 3+rand(100,1); pf(ind).intensities = pf(ind).intensities(:) .* factor; % Let's check the result plot(pf) {% endhighlight %}check for outliers
{% highlight matlab %} condition = pf.isOutlier; % remove outliers pf(condition) = []; % plot the corrected pole figures plot(pf) {% endhighlight %}Sometimes applying the above correction is not suffcient. Then it can help to repeat the outlier detection ones again
{% highlight matlab %} pf(pf.isOutlier) = []; plot(pf) {% endhighlight %}In the same way, as we removed the outlier one can manipulate and delete pole figure data by any criteria. Lets, e.g. cap all values that are larger than 500.
{% highlight matlab %} % find those values condition = pf.intensities > 500; % cap the values in the pole figures pf(condition).intensities = 500; plot(pf) {% endhighlight %}Sometimes it is necessary to rotate the pole figures. In order to do this with MTEX one has first to define a rotation, e.e. by
{% highlight matlab %} % This defines a rotation around the x-axis about 100 degree rot = rotation.byAxisAngle(xvector,100*degree); {% endhighlight %}Second, the command rotate can be used to rotate the pole figure data.
{% highlight matlab %} pf_rotated = rotate(pf,rot); plot(pf_rotated,'antipodal') {% endhighlight %}


--- layout: default ---
Apache NLPCraft® is an open source library for adding natural language Interface to modern applications. It enables people to interact with your products using voice or text.
Define the intents to interpret user input using any JVM-based language like Java, Scala, Groovy or Kotlin. Use REST API to integrate with your products.
Natural Language Interface enables users to interact with any type of products using natural language augmenting existing UI/UX with fidelity and simplicity of a familiar spoken language.
Natural Language has no learning curve, no special rules or UI to master, no cumbersome syntax or terms to remember - it's just a natural interface that your users already know.
Advanced Intent Definition Language (IDL) coupled with deterministic intent matching provide ease of use and unprecedented expressiveness for developing non-trivial intent comprehension.
Easily compose, mix and match new named entities out of built-in or external ones, creating new reusable named entity recognizers on the fly.
Advanced out-of-the-box support for maintaining and managing conversational context that is fully integrated with intent matching.
REST API and Java-based implementation natively supports the world's largest ecosystem of development tools, programming languages, frameworks and services.
NLPCraft supports any data source, device, or service - public or private. From databases and SaaS systems, to smart home devices, voice assistants and chatbots.
Everything you do with NLPCraft is part of your source code. No more awkward web UIs splitting your logic across different incompatible places. Model-as-a-code is built by engineers, and it reflects how engineers work.
Built with a singular focus - provide state-of-the-art developers with unprecedented productivity and efficiency when building modern natural language applications.
NLPCraft focuses on processing English language delivering the ease of use and unparalleled comprehension for the language spoken by more than a billion people.
NLPCraft natively integrates with 3rd party libraries for basic NLP processing and named entity recognition:
Apache NLPCraft is an effort undergoing incubation at The Apache Software Foundation (ASF), sponsored by the Apache Incubator. Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects.
While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF. Licensed under the Apache License, Version 2.0. Apache NLPCraft, Apache, the Apache feather, and the Apache NLPCraft project logo are either trademarks or registered trademarks of the Apache Software Foundation.


[Summary] [Package List] [Test Cases]
| Tests | Errors | Failures | Skipped | Success Rate | Time |
|---|---|---|---|---|---|
| 53 | 0 | 0 | 0 | 100% | 2.102 |
Note: failures are anticipated and checked for with assertions while errors are unanticipated.
[Summary] [Package List] [Test Cases]
| Package | Tests | Errors | Failures | Skipped | Success Rate | Time |
|---|---|---|---|---|---|---|
| org.apache.sling.feature.maven.mojos.apis | 5 | 0 | 0 | 0 | 100% | 0.038 |
| org.apache.sling.feature.maven.mojos | 39 | 0 | 0 | 0 | 100% | 1.775 |
| org.apache.sling.feature.maven.mojos.selection | 2 | 0 | 0 | 0 | 100% | 0.001 |
| org.apache.sling.feature.maven | 7 | 0 | 0 | 0 | 100% | 0.288 |
Note: package statistics are not computed recursively, they only sum up all of its testsuites numbers.
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| RegionSupportTest | 5 | 0 | 0 | 0 | 100% | 0.038 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| ApisJarMojoTest | 1 | 0 | 0 | 0 | 100% | 0.06 | |
| ExtractExtensionsMojoTest | 3 | 0 | 0 | 0 | 100% | 0.046 | |
| ScanTest | 1 | 0 | 0 | 0 | 100% | 0 | |
| FeatureSelectionConfigTest | 1 | 0 | 0 | 0 | 100% | 0.001 | |
| AnalyseFeaturesMojoTest | 2 | 0 | 0 | 0 | 100% | 0.913 | |
| AbstractIncludingFeatureMojoTest | 4 | 0 | 0 | 0 | 100% | 0.048 | |
| FeatureLauncherMojoTest | 5 | 0 | 0 | 0 | 100% | 0.283 | |
| AttachFeaturesMojoTest | 1 | 0 | 0 | 0 | 100% | 0.032 | |
| AggregateFeaturesMojoTest | 16 | 0 | 0 | 0 | 100% | 0.332 | |
| AbstractRepositoryMojoTest | 2 | 0 | 0 | 0 | 100% | 0.004 | |
| JarDecompressorTest | 3 | 0 | 0 | 0 | 100% | 0.056 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| TestIncludeExcludeMatcher | 2 | 0 | 0 | 0 | 100% | 0.001 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| JSONFeaturesTest | 2 | 0 | 0 | 0 | 100% | 0.007 | |
| SubstitutionTest | 4 | 0 | 0 | 0 | 100% | 0.012 | |
| PreprocessorTest | 1 | 0 | 0 | 0 | 100% | 0.269 |
[Summary] [Package List] [Test Cases]
| testGuessClassifier | 0.01 |
| testExtractJSONExtensionFromAggregate | 0.028 | |
| testExtractArtifactsFromAggregagte | 0.002 | |
| testExtractTxtExtensionFromFeatureFile | 0.004 |
| testInfoMatcher | 0 | |
| testLicenseDefaultsMatcher | 0 |
| testTaskConfiguration | 0 |
| testOrdering | 0 |
| testTaskConfigurationSupplied | 0.9 | |
| testTaskConfigurationOverridden | 0.006 |
| testSelectRefFiles | 0.036 | |
| testSelectAggregateClassifierFromFiles | 0.004 | |
| testSelectAggregateClassifierNotFound | 0.002 | |
| testSelectAggregateClassifier | 0.001 |
| testMainReflection | 0.224 | |
| testFullLaunch | 0.014 | |
| testMainReflectionFailure | 0.023 | |
| testSimpleFeature | 0.009 | |
| testFeatureFileReadingIssue | 0.011 |
| testApiExportWithToggles | 0.035 | |
| testApiExportWithTogglesOnly | 0 | |
| testApiExportAllPackages | 0.001 | |
| testNoRegionInfo | 0 | |
| testApiExportSubsetOfPackages | 0 |
| testAttachArtifacts | 0.03 |
| testCopyDecompressArtifactToRepository | 0 | |
| testCopyArtifactToRepository | 0.003 |
| testDecompress | 0.002 | |
| testJarWithEmbeddedJar | 0.011 | |
| testSignedJar | 0.042 |
| testFileReferenceInExtension | 0.004 | |
| testXMLFileReferenceInExtension | 0.001 |
| testReplaceAdditionalPropertiesMavenVarsWithSystemProperties | 0 | |
| testReplaceMavenVarsWithSystemProperties | 0.009 | |
| testOSGiVersion | 0 | |
| testReplaceMavenVars | 0 |
| testDependencyExclusions | 0.268 |


# Hands-on mobility data workshop ### 31.07.2019, Alexandra Kapp und Fabian Dinklage
## Slides https://technologiestiftung.github.io/citylab-slides/mobility-hands-on/ Notes: - During the input we will share some links for you
## Agenda - Context: Why bike-sharing data - Data collection - Data cleaning and data quality - Data Visualization - Pseudonymisation - **Data Dive:** Brainstorm Ideas - **Data Dive:** Start Analysis
## Context - **Why bike-sharing?** - Detailed mobility data for whole Berlin - (Non)-existent obligations of providers - Many possibilities: - urban planning, - businesses (e.g. mobility apps), - monitoring of compliance with city laws (e.g. prohibited parking zones) - **Data:** - trips of three bike-sharing providers for Berlin over three months period
## Use Cases What are interesting use cases, analyses and visualizations that are possible with this data?
## Procedure
## Data collection - APIs of bike-sharing providers: real-time locations of all available bikes - **Challenge 1**: Get Data from APIs - [Details on different APIs](https://lab.technologiestiftung-berlin.de/projects/bike-sharing/de/) - **Challenge 2**: Collecting all trips - Query all APIs every 4 minutes - Run script via Uberspace server with a cronjob - store data in a database (AWS RDS Postgres Database)
## Data collection
## Data Collection - **Challenge 3**: Amount of Data - With queries every 4 minutes and approx. 10.000 bikes thats: - 150.000 rows each hour - 3.500.000 rows each day - 25.000.000 rows each week
## Data Collection - **Challenge 3**: Amount of Data - After three month 20 GB storage was full - Start of daily cleaning script (again: cronjob on Uberspace): Delete all rows, were the location of the bike did not change (Reduction from 1.5 billion to 5 million rows) _
## Data Cleaning [Jupyter Notebook with cleaning code](https://github.com/technologiestiftung/bike-sharing/blob/master/src/analysis/preprocess.ipynb)
## Data Cleaning: Implausible Peaks over time
## Data Cleaning: Implausible Provider
## Data Cleaning - **Raw:** 1,5 Billion rows - **After cleaning of database:** 4,9 Mio rows - **Remove data outside Berlin:** 4,8 Mio rows - **Merge locations to trips:** 2,4 Mio. trips - **Remove trips < 200 meters OR trips longer than 24 h OR trips faster than 30 km/h:** 0,5 Mio. trips - **Remove provider with implausible data:** 0,3 Mio. trips
## How to approach large datasets: - visually appealing - with good performance - in it's completeness Note: - In the next slides we dive into the process of visualizing this dataset - Now we're at the point where we're generating tons of cleaned data in our db - So how handle and visualize these in an appropriate way?
## Introducing Deck.gl - visualize large-scale Geospatial Data - variety of visualization layers out of the box available - hardware accelerated (Web.gl) Note: - If you want to handle large geospational datasets - visualizing them as nodes on the browser can be a pain in the ass - Fortunately there are hardware accelerated solutions (Web.gl) - One approach is the framework deck.gl
## [Deck.gl examples](https://deck.gl/#/examples/core-layers/geojson-layer-paths) Note: - the framework makes it possible to visualize 100.0000s of datapoints - as you can see at this example of mobility networks in the states - The framework provides a set of different layers for geospatial data - please check out other example such as the geojson layer mapping property values on districts of the city - all layers use the hardware accelerated map service mapbox as well - The documentation is extensive - Preformed containers where you can just throw your data in - For our data we decided to start with the trips layers - Before we go into detail about data preprocessing let's have a look into the visualisation
## [Our prototype](https://fabiandinklage.com/projects/bikesharing/) Note: - We wanted to make the topic of shared mobility more tangible - This visualization is based on the [trips layer](https://github.com/uber/deck.gl/tree/master/examples/website/trips) - Buildings layer added - Camera Handler to show specific spots on the map - daily data is made available through some magic in the backround - Daily Trips peaks Histogram for analysis purposes in d3 - Now let's check out how things work under the hood.
## Data output - bikes-accessible.geojson - bikes-trips.geojson - bikes-trails.json Note: - To make the data most accessible we're generating a set of three distinct datasets from the database - In order to accomplish that, a set of calculation steps are necessary
## Required steps - aggregate bike rows to trips - Creates (possible) routes with start- and endpoints - Calculate distances between waypoints ([Turf.js](https://turfjs.org/)) - Speed of bike trips - Save in appropriate data format for visualization Note: - we created a node script that accomplishes all these steps - we aggregate the data from the database - sorted the db by bikeid and time - if the time changes but location doesn't, the bike is accessible during that time - all rows where location doesn't change are removed - if time and location changes, the bike is being used - First we used a service provider (Here, Osm, Google) to calculate routes between - let me show you what's meant by that: - we have start and endpoint of one bike with two timestamps - but we don't know how the bike came from a to b - The Api just needs a start and end location and delivers waypoints of a possible route - in our special case we also need to calculate the distances between the routed waypoints - compare distances with total trip length to find out the speed of a bike - this information is only interesting if we want to animate bike over time - which is what we are actually doing in our viz - after doing the calculations - Transfer the data into appropiate geojson files - In the first step we did it for one weekend - Make use of the geojson format - As a little refreshment here an overview of the gejson
```javascript const geojson = { "type": "FeatureCollection", "features": [ { "type": "Feature", "geometry": { "type": featureType, // point, polygon, line and more ... "coordinates": [] // [lat,lng] here. }, "properties": { ... } } ] } ``` Notes: - Object with a key that holds an array - Each object in array represents one item, depending on the type your geojson has - Inside the properties key more data about the item that can be stored
```javascript [ { "vendor": 0, "segments": [ // all segments represent a trip [ 13.3782979, // longitude 52.5076544, // latitude 39497.8 // timestamp ], ... ] } ] ``` Notes: - in case of animted trips, the data format has to be changed a little - you have an array of objects - the vis will interpolate between two locations and timestamps - bikes will move in between - first we did this fow two days and it was already more than 20mb to load - which leads to the next question:
## How does it scale? - make newest data inside visualization available (another **[cronjob](https://gist.github.com/fdnklg/2c784e82735a3122acf1c07009795fd4)**) - transform and write data daily (cronjob at **[uberspace](https://uberspace.de/en/)**) - create own routing service (**[osrm-docker](https://hub.docker.com/r/osrm/osrm-backend/)** at **[aws](https://docs.aws.amazon.com/efs/latest/ug/gs-step-one-create-ec2-resources.html)**) Note: - Automate your processes - If you want to visualize up to date mobility data for each day a couple of steps are necessary - To become independent from request limits of routing providers it's possible to use open source solutions like osrm - I just want to briefly tell you how the different services are working together - If you're interested how things work on a deeper level we can later dive into the code together
## Pseudonymisation - **NO** unique bike ID and **NO** provider ID given - Fields: - TripID - a unique ID - Start date & time rounded to the nearest 15 minutes - End date & time rounded to the nearest 15 minutes - StartLatitude - rounded to nearest 3 decimal places - StartLongitude - rounded to nearest 3 decimal places - EndLatitude - rounded to nearest 3 decimal places - EndLongitude - rounded to nearest 3 decimal places - TripDuration - duration of the trip minutes - TripDistance - distance of trip in miles based on company route data [Standard of Harvard Civic Analytics Network](https://data.louisvilleky.gov/dataset/dockless-vehicles)
## Pseudonymisation - **pseudonomysed_raw.csv**: anononymised raw data (2.5M trips) - **pseudonomysed.csv**: cleaned anonymised raw data (0.3M trips)
## Data Dive - Ideas **get into small groups** **15 min** define research questions or sketch visualization ideas
## Data Dive - Data ### Raw Data: https://send.firefox.com/download/1d2460498f803b0f/#euosKRfI1-2si_il9sbqpg ###### . ### Preprocessed for DeckGL: https://send.firefox.com/download/471fca96e8e734d3/#3LPMEYJawiE7j8cHR0f-Zg ###### . ### GitHub Repo Data Collection and Analysis: https://github.com/technologiestiftung/bike-sharing ###### . ### GitHub Repo Visualization: https://github.com/technologiestiftung/deck-gl-geojson-example
## Data analysis - Option 1: Work with data yourself - Option 2: Follow examples of analysis in Jupyter Notebook - Option 3: Try out visualizations with DeckGL
## Results
## Contact: ### Alexandra Kapp<EMAIL_ADDRESS>[@lxndrkp](https://twitter.com/lxndrkp) ###### . ###### . ### Fabian Dinklage<EMAIL_ADDRESS>[@fdnklg](https://twitter.com/fdnklg) ###### . ###### . [@citylabberlin](https://twitter.com/citylabberlin)\ [citylab-berlin.org](https://citylab-berlin.org)


Validation demonstration
Username
Email
Discount code
(The 5 digit number you received by email)
Submit


A review by John Beachem
* * * 1/2
CAST Martin Lawrence - Miles Logan Luke Wilson - Carlson Peter Greene - Deacon Dave Chappelle - Tulley Nicole Parker - Melissa Green
`Blue Streak', Martin Lawrence's newest outing and first appearance without a big name star by his side (Life, Bad Boys), may be cliched and formulaic, but it entertains, none the less. However, be warned that if you're not a Martin Lawrence fan you should stay far away from this film, as it is carried almost entirely by his comic antics.
The story opens with a gang of high-tech thieves led by Miles Logan breaking into what appears to be a jewelry store. The robbery has just been completed, when one of the gang pulls a double cross and accidentally alerts the police. Miles manages to secure the stolen gem in an air duct of an uncompleted building before the police catch him. Two years later, released from prison, Miles goes back to recover his prize only to discover that the building is now a police station. What is the most obvious solution? Why, to disguise himself as a cop and join the ranks of course.
As a by-the-numbers piece of film making, it is fairly easy to guess the outcome of this movie from the start, though I won't reveal it here. In fact, the only things that truly make this worth seeing are the performances by Martin Lawrence and Luke Wilson as his likable, yet incredibly naive partner. Lawrence's talent stems mainly from his exaggerated speech and facial expressions, and he puts this talent to good use here. Just watch his expressions in a scene in which a dozen or so cops have cornered him and are asking what his opinion is about some new piece of police equipment.
Unfortunately, there are some rather large problems with this movie in addition to the predictable script. First, there are several utterly pointless characters such as Melissa Green, a defense attorney who appears in only three or four scenes, and is apparently present only so the audience can dislike her. The film's largest annoyance comes from Tulley, who is a friend of Logan's from the jewel heist. Chappelle has such a whiny, obnoxious voice that I saw several people in the audience cringing whenever he spoke.
Despite these problems, the movie is a lot of fun, and Lawrence is clearly having the time of his life making it. I simply hope that next time he finds a more original script to house his rather considerable comic talent. For delivering a lot of chuckles and a few belly laughs, I give `Blue Streak' three and a half stars and a recommendation to try and catch a matinee.
* * * * * - One of the greatest movies ever made, see it now. * * * * - Great flick. Try and catch this one. * * * - Okay movie, hits and misses. * * - Pretty bad. See it if you've got nothing better to do. * - One of the worst movies ever. See it only if you enjoy pain.
E-mail with comments at<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


From: The Mind, Brain, Body
A Logical, Smart,
Awesome-sauce Person.
21 June 2021
To : The Sclera, Retina, Optic Nerve
Optic Chiasm, Lateral Geniculate Body
Optic Radiation, Cortical Centre, Brain,
(Heart too, hopefully)
Prachi Merchant.
Dear Prachi,
I feel like I’ve written you so many cards over the years, long messages, or simply even just talking to you, giving you ‘advice’.
 This would not be a birthday card where I would write the number of years you’ve been born, or how annoying you are (even though OH MY GOD YOU’RE LIKE SOOOO ANNOYING).
 I can’t even begin to imagine what you must be feeling or what your parents, your sister or Shaina would be feeling.
But I’m so so so so so proud of how far you’ve come. I remember when you called me that day and it broke my heart (sorry for being so sappy).  But we’ve been talking and you SEEM so much better I can only hope you’d be feeling better than you were.
Remember that your weakness today is your strength tomorrow.  I love you so much,Prachi, you already know that.  You’ve got this amazing future in front of you that you can pave your way for, structure on your own, it’s all waiting for you. Last year was so much different from this birthday, but tomorrow is going to be better (it’s a metaphor, I don’t literally mean tomorrow). You have purpose, that’s why you’re here. That’s what so many of us keep you going, we care more about you than you could ever know, Prach. Also you gotta keep pushing for the sake of things like, ice cream, movies, shows, crazy,stupid,fun stories, or simply just sunsets and hatred of cats.
I promised you a Starbucks trip (that you bailed on me), Polar Bear, fries from Happy Endings and hopefully so much more that we can do once everything goes back to normal. And I can’t wait for things to turn for the better! It’s going to be so much sauce ness fun.
Take a day of bro. You deserve one day to just chill, relax.  You got this Prachi.
Love, Amima.


Was there a definitive solution to the BSOD?
Posted: Mon Sep 01, 2008 7:36 pm
So totally out of the blue I got a BSOD on Exo and now every time I try to log in I get it. Was there ever a definitive fix for this or not?
Game Development and More
http://unseenstudios.com/community/
http://unseenstudios.com/community/viewtopic.php?f=32&t=1028


Again, thank you for choosing to donate to {{getOrgName()}}!
The amount you wish to donate and your payment information is displayed below. Please confirm your information and go back and make any changes should something be incorrect.
Your Donation Amount: ${{getDonationAmount()}}
Card Holder Name: {{getCardHolderName()}}
Street Address: {{getStreetAddress()}}
City: {{getCity()}}
State: {{getState()}}
Card Number: {{getCardNumber()}}
Expiration Date: {{getCardExpDate()}}
Card CVC: {{getCardCVC()}}
Email Address: {{getEmail()}}


Network¶
The Network component plays an important role in QuNetSim. In each simulation, one must configure a network with hosts. Each host defines its classical and quantum connections and when the host is added to the network, the network builds on the two graph objects for each type of connection it maintains. With these two network graphs, one can define their own routing algorithms for each type of network (e.g. there can be different routing algorithms for quantum and classical information). The default routing algorithm is set to the shortest path route between the two hosts.
The most commonly used methods for Network are:
add_host(host)
Add a host to the network
remove_host(host)
Remove a host from the network
update_host(host)
Updates the network graph when the connections of a host change
get_host(host_id)
Get the host object given the host_id
get_APR()
Get the information for all the hosts in the network
(property) quantum_routing_algo(function)
Property for the quantum routing algorithm. It should be a function with parameters that take a source ID and a destination ID and returns an ordered list which represents the route.
(property) classical_routing_algo(function)
Property for the classical routing algorithm. It should be a function with parameters that take a source ID and a destination ID and returns an ordered list which represents the route.
(property) use_hop_by_hop(bool)
If the network should recalculate the route at each node in the route (set to True) or just once at the beginning (set to False)
(property) delay(float)
the amount of delay the network should have. The network has the ability to throttle packet transmissions which is sometimes neccessary for different types of qubit / network backends.
(property) packet_drop_rate(float)
The probability that a packet is dropped on transmission in the network
(property) x_error_rate(float)
The probability that a qubit has an \(X\) gate applied to in at each host in the route
(property) z_error_rate(float)
The probability that a qubit has an \(Z\) gate applied to in at each host in the route
draw_classical_network
Generate a depiction of the classical network
draw_quantum_network
Generate a depiction of the quantum network (via matplotlib)
-
class
qunetsim.components.network.
Network
¶ Bases:
object
A network control singleton object.
-
_encode
(route, payload, ttl=10)¶ Adds another layer to the packet if route length between sender and receiver is greater than 2. Sets the protocol flag in this layer to RELAY and payload_type as SIGNAL and adds a variable Time-To-Live information in this layer.
- Parameters
route – route of the packet from sender to receiver
payload (Object) – Lower layers of the packet
ttl (int) – Time-to-Live parameter
- Returns
Encoded RELAY packet
- Return type
-
_entanglement_swap
(sender, receiver, route, q_id, o_seq_num, blocked)¶ Performs a chain of entanglement swaps with the hosts between sender and receiver to create a shared EPR pair between sender and receiver.
- Parameters
-
_establish_epr
(sender, receiver, q_id, o_seq_num, blocked)¶ Instead doing an entanglement swap, for efficiency we establish EPR pairs directly for simulation, if an entanglement swap would have been possible.
-
_process_queue
()¶ Runs a thread for processing the packets in the packet queue.
-
_remove_network_node
(host)¶ Removes the host from the ARP table.
- Parameters
host (Host) – The host to be removed from the network.
-
_route_quantum_info
(sender, receiver, qubits)¶ Routes qubits from sender to receiver.
-
_update_network_graph
(host)¶ Add host host to the network and update the graph representation of the network
- Parameters
host – The host to be added
-
add_host
(host)¶ Adds the host to ARP table and updates the network graph.
- Parameters
host (Host) – The host to be added to the network.
-
add_hosts
(hosts)¶ Adds the hosts to ARP table and updates the network graph.
- Parameters
hosts (list) – The hosts to be added to the network.
-
property
classical_routing_algo
¶ Get the routing algorithm for the network.
-
property
delay
¶ Get the delay interval of the network.
-
draw_classical_network
()¶ Draws a plot of the network.
-
draw_quantum_network
()¶ Draws a plot of the network.
-
generate_c_topology
(host_names: list, topology: str = 'mesh') → None¶ Adjusts a network that already exists by adding quantum connections that fit the desired network topology. This method either adds new nodes or adds connections to existing hosts within the network.
The supported network topologies are mesh, star, ring, linear, and tree.
- Parameters
host_names (list) – The names for the new hosts.
topology (str) – The network topology that will be created.
-
generate_q_topology
(host_names: list, topology: str = 'mesh') → None¶ Adjusts a network that already exists by adding quantum connections that fit the desired network topology. This method either adds new nodes or adds connections to existing hosts within the network.
The supported network topologies are mesh, star, ring, linear, and tree.
- Parameters
host_names (list) – The names for the new hosts.
topology (str) – The network topology that will be created.
-
generate_topology
(host_names: list, topology: str = 'mesh') → None¶ Adjusts a network that already exists by adding both classic and quantum connections that fit the desired network topology. This method either adds new nodes or adds connections to existing hosts within the network.
The supported network topologies are mesh, star, ring, linear, and tree.
- Parameters
host_names (list) – The names for the new hosts.
topology (str) – The network topology that will be created.
-
get_ARP
()¶ Returns the ARP table.
- Returns
The ARP table
- Return type
dict
-
get_classical_route
(source, dest)¶ Gets the route for classical information from source to destination.
- Parameters
source (str) – ID of the source host
dest (str) – ID of the destination host
- Returns
An ordered list of ID numbers on the shortest path from source to destination.
- Return type
route (list)
-
get_host
(host_id)¶ Returns the host with the host_id.
-
get_host_name
(host_id)¶ - Parameters
host_id (str) – ID number of the host whose name is returned if it is in ARP table
Returns the name of the host with host_id if the host is in ARP table , otherwise returns None.
- Returns
Name of the host
- Return type
dict or None
-
get_quantum_route
(source, dest)¶ Gets the route for quantum information from source to destination.
- Parameters
source (str) – ID of the source host
dest (str) – ID of the destination host
- Returns
An ordered list of ID numbers on the shortest path from source to destination.
- Return type
route (list)
-
property
packet_drop_rate
¶ Get the drop rate of the network.
-
property
quantum_routing_algo
¶ Gets the quantum routing algorithm of the network.
- Returns
The quantum routing algorithm of the network
- Return type
algorithm (function)
-
remove_host
(host)¶ Removes the host from the network.
- Parameters
host (Host) – The host to be removed from the network.
-
send
(packet)¶ Puts the packet to the packet queue of the network.
- Parameters
packet (Packet) – Packet to be sent
Returns boolean value dependent on if the sender and receiver share an EPR pair.
-
start
(nodes=None, backend=None)¶ Starts the network.
-
stop
(stop_hosts=False)¶ Stops the network.
-
update_host
(host)¶ Update the connections of a host in the network. :param host:
Returns:
-
property
use_hop_by_hop
¶ Get the routing style for the network.
- Returns
If the network uses hop by hop routing.
-


--- title: "2015: Year in Books | Goodreads" author: Janani Ravi date: '2017-01-01' slug: goodreads-2015 categories: - Books-Blogs tags: - books # - review summary: "My Year in Books: 2015!" ---
Find my latest reads & recommendations on Goodreads!


{% extends "base.html" %} {% block title %}Instances by Statistic{% endblock %} {% block content %} {%- if statBreakdown -%}
There are no instances.


Reports Landing Page
A list of applicable reports will be displayed. Change the view to see a different list of reports.


--- layout: default ---
Indiana University, Computer Science, Bloomington, Indiana (Ph. D, Oct. 2016)
Indiana University, Computer Science, Bloomington, Indiana (MS, May. 2007)
Konkuk University, Computer Science, Seoul, Korea (BS, Feb. 2005)
Assistant professor, Sookmyung Woman's University (2017 ~ Current)
Lecturer, Seoul National University, Seoul, Korea (2016)
Researcher, Bioinformatics Institute, Seoul National University, Seoul, Korea (2011 ~ 2016)
Research Assistant, Indiana University, Indiana, USA (2006 ~ 2011)
Local arrangement chair, 2020 Asia Pacific Bioinformatics Conference (APBC 2020)
Board of director member & manager, Korean AI society (2017~2018)
Publication chair, The Seventh International Conference on Emerging Databases
– Technologies, Applications, and Theory (EDB2017)
Local arrangement chair, 2017 IEEE International Conference on Big Data and Smart Computing (BigComp 2017)
Session Chair, 2017 IEEE International Conference on Big Data and Smart Computing (BigComp 2017)


Import your existing projects from GitHub. Create job postings for bugs and issues to be fixed and new features to be implemented. Encourage team contributions by award developer reputation.
Browse or search for site users. Send a project join request to a developer whose skills match those of the project or potential job.
Make positive contributions to projects and recieve developer reputation bonuses. The higher your reputation, the more likly you are to be invited to work on new, exciting projects.
If you encounter an issue or have an idea for any improvement, we would like to know!
Please submit an issue on our github page or contact us