--- layout: default title: HCAN Sourcing | We Manage, Optimize and Grow Your Amazon Business permalink: / page-class: home description: page-hero-bg: hero-bg-2.jpg page-hero-title: We Manage, Optimize and Grow Your Amazon Business. page-hero-cta: LEARN MORE page-hero-cta-link: "#link-target" full-width-cta-white-headline: Amazon can be difficult for companies to manage. full-width-cta-white-text: '
From optimizing listings to issues with MAP compliance, some businesses even grow to hate dealing with Amazon.
That’s where we come in.
Our goal is to be the strategic partner in the Amazon side of your business. We have years of e-commerce experience and a deep understanding of the Amazon infrastructure which will maximize profitability and minimize problems for Your Business.
' full-width-cta-white-btn-text: CONTACT US full-width-cta-white-btn-link: #contact three-col-img-l: lock.svg three-col-img-l-alt: Lock Logo three-col-img-l-title: Listing Optimization three-col-img-l-text: We fully optimize to ensure high quality images, up to date product descriptions and more all to ensure an enhanced sell through rate three-col-img-c: money.svg three-col-img-c-alt: Money Logo three-col-img-c-title: MAP Compliance three-col-img-c-text: We help ensure MAP compliance within the Amazon ecosystem to prevent brand erosion and keep your brick & mortar retailers happy three-col-img-r: check.svg three-col-img-r-alt: Check Logo three-col-img-r-title: Brand Protection three-col-img-r-text: We help identify and remove unauthorized sellers of your products to ensure only approved sellers are listing your products home-page-sec-4-headline: We offer a full service Amazon solution. home-page-sec-4-text: 'If you’re not selling your products on Amazon, someone else probably is.
Like it or not, we live in the age of Amazon. That’s why its so important to stake your brands place in the worlds bigget marketplace. Thankfully, we can do the hard work for you!


For ProxyToys, we tracks and manages issues on Codehaus's JIRA, installation.
Before you can report, comment or vote for an issue you need an account in JIRA. You will find in the upper right corner of the JIRA mask a Login link. Follow it and either login if you already have an account otherwise simply sign up. This is necessary to reduce spam in the system and as benefit you can be notified if work is completed for the issues you report.
Please, before opening a new issue look through the open or resolved ones, you may already find your problem. Also do not use the system to ask questions, for that purpose we have a user list. We read the list continuously. If you are unsure whether the problem is caused by a bug or your usage of ProxyToys, use the user's list first. If we can confirm a bug, you may still open an issue. Also do not report on the list that you have created a new issue, we are already notified by the system.
If you like to contribute code, we prefer a patch/diff in contrast to the complete modified file - unless the file itself is new. Please provide also unit tests, ProxyToys has a high test coverage and we like to keep this way. Additionally, if you provide new files, please also add a header with the copyright. It must be a BSD license, simply take the header of any other file in the distribution as template. Otherwise we might not be able to add any code you donate.
JIRA is made by Atlassian, and free for open source use. See its homepage.


| | |
- data_unscale(X, y, scalarX, scalarY)
- Unscale data to original range
- load_data(filepath)
- Load training and testing data from df
- manage_inf(x)
- Replaces values that are inf to the max non-inf value
- resize_descriptors(df)
- Resizes bond, angle, coulomb matrix such that each value is a single
descriptor
- split_and_scale(X, y)
- Preprocesses data such that all values are scaled in range [0,1],
defined by training set only
|


The topics that are covered consist of bugs, spec, SDLC, black box testing, programming, automation,and the list goes on.
The tools used in the QA track are pair testing, open source code editors, github, and the software testing book.
Pair Testing is a software testing technique in which two people test the same feature at the same place at same time by continuously exchanging ideas. It generates more ideas which result in better testing of the application under test.
GitHub is a Web-based Git repository hosting service. It offers all of the distributed revision control and source code management (SCM) functionality of Git as well as adding its own features.
Software Testing, Second Edition provides practical insight into the world of software testing and quality assurance. Learn how to find problems in any computer program, how to plan an effective test approach and how to tell when software is ready for release. Updated from the previous edition in 2000 to include a chapter that specifically deals with testing software for security bugs, the processes and techniques used throughout the book are timeless.


Apple sends out invites for a December app awards event
The unexpected event will highlight the company’s favourite third-party apps and developers
by Henry BurrellIn an unexpected move, Apple will host an event on 2 December in New York City that looks to celebrate apps and developers. The company sent out invitations to US media on Monday, with those media duly tweeting the proof they are in Apple’s inner circle.
It seems to us like this is a partner event six months on from WWDC, Apple’s Worldwide Developer Conference. While details are scant, this new event looks to be an awards-style ceremony celebration of apps and games.
Apple does also hold a Design Awards at WWDC.
The use of “created by the best” in the invite refers to iOS and Mac developers who create third-party apps and hold up the App Store ecosystem, helping to sell millions of Apple devices a year.
This end of year celebration of apps and games will also champion Apple’s successful launch of Apple Arcade, it’s paid gaming service. We’ll wait to see how self-congratulatory the whole thing is. It's unlikely that Apple will use the event to announce new hardware, but we can dream.


This 7-course graphic design bundle is just $39 today
by DealPost TeamThere’s never been a better time to work in graphic design, thanks to a growing demand for talented artists who can create everything from web pages to print layouts.
But if you want to stand out from the crowd, you need to have the right skills under your belt. The School of Graphic Design Mastery Bundle will help you land some of the best positions in the industry, and it’s available for over 95% off at just $39.
With seven courses and forty hours of training led by industry experts, this bundle will teach you how to work with graphic design’s most important and powerful tools.
You’ll learn how to use Adobe Illustrator in order to create everything from full-fledged artwork to logos, how to build your creative pallet by integrating new design methods, how to use Photoshop in order to professionally edit your photos, and much more.
There’s also instruction that teaches you how to use your new skills in the field of web development.
Get the skills you need to become an in-demand graphic design professional with the School of Graphic Design Mastery Bundle for just $39—over 95% off its usual price.
Prices are subject to change.
Don't wait for Black Friday — you can get these top-sellers at deep discounts today!
This story, "This 7-course graphic design bundle is just $39 today " was originally published by TechConnect .


ITCA
Home
About us
Gallery
Contact
Frequently Ask Questions
contact us page
First Nmae
Last Nmae
Email
Phone
Message
Social
Phone
xxxx
xxxx
xxxx
Email
egfhcgmhfnbs
agehjghmghfd
Address
brix
kombo
Banjul, The Gambia
f
I
N
D
US
About
About
Privacy
Terms & Conditions
Stay In touch
Subscribe


mustaching 3.1.0 Documentation¶
Introduction¶
A tiny Python 3.4+ library inspired by Mr. Money Mustache to summarize and plot personal finance data given in a CSV file of transactions. Uses Pandas and Python-Highcharts to do most of the work.
Smacks of plain text accounting but is limited to single-entry transactions and focuses only on income and expenses. For full-feature double-entry bookkeeping in Python, use a different library, such as beancount.
Installation¶
- Using Pipenv, do
pipenv install git+https://github.com/araichev/mustaching#egg=mustaching
- Alternatively, using Pip and a virtual environment, do
pip install git+https://github.com/araichev/mustaching
Usage¶
Play with the IPython notebook at ipynb/examples.ipynb
.
You can even do so online by clicking the Binder badge above.
Using Binder you can also upload your own transaction data into the notebook, but consider first Binder’s warning about private data.
Your CSV of transactions should contain at least the following columns
'date'
: string; something consistent and recognizable by Pandas, e.g 2016-11-26'amount'
: float; amount of transaction; positive or negative, indicating an income or expense, respectively'description'
(optional): string; description of transaction, e.g. ‘dandelion and burdock tea’'category'
(optional): string; categorization of description, e.g. ‘healthcare’'comment'
(optional): string; comment on transaction, e.g. ‘a gram of prevention is worth 16 grams of cure’
The business logic can be found in mustaching/main.py
Notes¶
- Development status: Alpha
- This project uses semantic versioning
Authors¶
- Alex Raichev, 2016-11
API¶
mustaching.main module¶
- CONVENTIONS:
- A DataFrame of transactions is one with the following columns:
- date: Numpy datetime
- amount: float
- description (optional): string
- category (optional): Pandas ‘category’
- comment (optional): string
-
mustaching.main.
create_transactions
(date1, date2, freq='12H', income_categories=None, expense_categories=None)¶ Create a DataFrame of sample transactions between the given dates (date strings that Pandas can interpret, such as YYYYMMDD) and at the given Pandas frequency. Include all the columns in the set
COLUMNS
. Each positive transaction will be assigned a income category from the given listincome_categories
, and each negative transaction will be assigned a expense category from the given listexpense_categories
. If these lists are not given, then whimsical default ones will be created.
-
mustaching.main.
find_columns
(raw_transactions)¶ Given a DataFrame, lowercase the column names and search for the columns in
COLUMNS
. Build a dictionary of the form name inCOLUMNS
-> name in given DataFrame and return the result, which might not contain all theCOLUMNS
keys.
-
mustaching.main.
get_colors
(column_name, n)¶ Return a list of
n
(positive integer) nice RGB color strings to use for color coding the given column (string; one of['income', 'expense', 'period_budget', 'balance']
.NOTES:
- Returns at most 6 distinct colors. Repeats color beyond that.
- Helper function for
plot()
.
-
mustaching.main.
insert_repeating
(transactions, amount, freq, description=None, category=None, comment=None, start_date=None, end_date=None)¶ Given a DataFrame of transactions, add to it a repeating transaction at the given frequency for the given amount with the given optional description, category, and comment. Restrict the repeating transaction to the given start and end dates (date objects), inclusive, if given; otherwise repeat from the first transaction date to the last. Drop duplicate rows and return the resulting DataFrame.
-
mustaching.main.
plot
(summary, currency=None, width=None, height=None)¶ Given a transaction summary of the form output by
summarize()
, plot it using Python HighCharts. Include the given currency units (string; e.g. ‘NZD’) in the y-axis label. Override the default chart width and height, if desired.
-
mustaching.main.
read_transactions
(path, date_format=None, **kwargs)¶ Read a CSV file of transactions located at the given path (string or Path object), parse the date and category, and return the resulting DataFrame.
The CSV should contain at least the following columns
'date'
: string'amount'
: float; amount of transaction; positive or negative, indicating a income or expense, respectively'description'
(optional): string; description of transaction, e.g. ‘dandelion and burdock tea’'category'
(optional): string; categorization of description, e.g. ‘healthcare’'comment'
(optional): string; comment on transaction, e.g. ‘a gram of prevention is worth 62.5 grams of cure’
If the date format string
date_format
is given, e.g'%Y-%m-%d'
, then parse dates using that format; otherwise use let Pandas guess the date format.
-
mustaching.main.
summarize
(transactions, freq=None, by_category=False, decimals=2, start_date=None, end_date=None)¶ Given a DataFrame of transactions, slice it from the given start date to and including the given end date date (strings that Pandas can interpret, such as YYYYMMDD) if specified, and return a DataFrame with the columns:
'date'
: start date of period'category'
(if by_category): transaction category'amount'
: amount for the period and category'balance'
: cumulative sum of income - expense'savings_pc_for_period'
: 100*(income sum - expense sum)/(income sum)'spending_pc_for_period'
: 100*expense/(income sum)'spending_pc_for_period_and_category'
(if by_category): 100*expense/(income sum)'income_pc_for_period_and_category'
(if by_category): 100*income/(income sum)'expense_pc_for_period_and_category'
(if by_category): 100*expense/(expense sum)'daily_avg'
(if freq is None): income - expense divided by number of days between start and end date'weekly_avg'
(if freq is None): income - expense divided by number of weeks between start and end date'monthly_avg'
(if freq is None): income - expense divided by number of months (possibly fractional) between start and end date'yearly_avg'
(if freq is None): income - expense divided by number of years (possibly fractional) between start and end date
The period is given by the Pandas frequency string
freq
. If that frequency isNone
, then there is only one period, namely one that runs from the first to the last date intransactions
(ordered chronologically); the'date'
value is then the first date.If
by_category
, then group by the'category'
column oftransactions
in addition to the period.Round all values to the given number of decimals.


Hemi JavaScript Framework
Hemi.worker
Description
The worker is a managed wrapper for the HTML 5 DOM Worker. Hemi Worker implements the Hemi Module service to inject the target worker script with the Module API, add a lightweight Psuedo Worker API for browsers that don't support Worker, and add a bootstrap to browsers that do support Worker so the Worker runs in the Hemi framework.
Class Index
-
static Hemi.worker.service: Static implementation of the hemi.worker.serviceImpl class.
-
Hemi.worker.serviceImpl: The worker service provides a wrapper for adding the Hemi Module API to Worker scripts, and adding a lightweight wrapper for browsers that don't support Workers.
static Hemi.worker.service
version 4.0.1
Static implementation of the hemi.worker.serviceImpl class.
Hemi.worker.serviceImpl
version 4.0.1
The worker service provides a wrapper for adding the Hemi Module API to Worker scripts, and adding a lightweight wrapper for browsers that don't support Workers.
Index
Object Index
-
public PsuedoWorker: A lightweight Worker implementation. Includes all FrameworkObject members.
Method Index
-
public NewWorker: Creates a new Worker or PsuedoWorker object, depending on browser support.
Objects
PsuedoWorker
A lightweight Worker implementation. Includes all FrameworkObject members.
Methods
Methods
NewWorker
Creates a new Worker or PsuedoWorker object, depending on browser support.
Syntax
vWorker = NewWorker(
sName, sPath, oContainer
)
Parameters
-
sName as String : Name of the worker script.
-
sPath as String (optional): Parent path to the script which the worker will process.
-
oContainer as XHTMLComponent (optional): XHTML Component acting as a container for the module.
Returns
vWorker as Worker: A Worker or PsuedoWorker object..
[ Hemi JavaScript Framework - Stephen W. Cote, 2002 - 2013. ]


| YOUR NAME: | {{ confirmation.payment.name|upper }} {{ confirmation.payment.last_name|upper }} | |
| CONFIRMATION NUMBER: | {{ confirmation.code }} | |
| TRIP: | {{ confirmation.payment.trip.name|upper }} | |
| PRICE: | $ {{ confirmation.payment.trip.price_sale }} | |
| STATUS: | PAID | |
| DATE: | {{ confirmation.payment.trip.date|upper }} |


#define _GNU_SOURCE /* See feature_test_macros(7) */ #include <unistd.h> #include <sys/syscall.h> /* For SYS_xxx definitions */ long syscall(long number, ...);
syscall() saves CPU registers before making the system call, restores the registers upon return from the system call, and stores any error code returned by the system call in errno(3) if an error occurs.
Symbolic constants for system call numbers can be found in the header file <sys/syscall.h>.
For example, on the ARM architecture Embedded ABI (EABI), a 64-bit value (e.g., long long) must be aligned to an even register pair. Thus, using syscall() instead of the wrapper provided by glibc, the readahead() system call would be invoked as follows on the ARM architecture with the EABI:
syscall(SYS_readahead, fd, 0, (unsigned int) (offset >> 32), (unsigned int) (offset & 0xFFFFFFFF), count);
Since the offset argument is 64 bits, and the first argument (fd) is passed in r0, the caller must manually split and align the 64-bit value so that it is passed in the r2/r3 register pair. That means inserting a dummy value into r1 (the second argument of 0).
Similar issues can occur on MIPS with the O32 ABI, on PowerPC with the 32-bit ABI, and on Xtensa.
The affected system calls are fadvise64_64(2), ftruncate64(2), posix_fadvise(2), pread64(2), pwrite64(2), readahead(2), sync_file_range(2), and truncate64(2).
The first table lists the instruction used to transition to kernel mode, (which might not be the fastest or best way to transition to the kernel, so you might have to refer to vdso(7)), the register used to indicate the system call number, and the register used to return the system call result.
| arch/ABI | instruction | syscall # | retval | Notes |
| arm/OABI | swi NR | - | a1 | NR is syscall # |
| arm/EABI | swi 0x0 | r7 | r0 | |
| blackfin | excpt 0x0 | P0 | R0 | |
| i386 | int $0x80 | eax | eax | |
| ia64 | break 0x100000 | r15 | r10/r8 |
bool error/
errno value |
| parisc | ble 0x100(%sr2, %r0) | r20 | r28 | |
| s390 | svc 0 | r1 | r2 | See below |
| s390x | svc 0 | r1 | r2 | See below |
| sparc/32 | t 0x10 | g1 | o0 | |
| sparc/64 | t 0x6d | g1 | o0 | |
| x86_64 | syscall | rax | rax |
For s390 and s390x, NR (the system call number) may be passed directly with "svc NR" if it is less than 256.
The second table shows the registers used to pass the system call arguments.
| arch/ABI | arg1 | arg2 | arg3 | arg4 | arg5 | arg6 | arg7 |
| arm/OABI | a1 | a2 | a3 | a4 | v1 | v2 | v3 |
| arm/EABI | r0 | r1 | r2 | r3 | r4 | r5 | r6 |
| blackfin | R0 | R1 | R2 | R3 | R4 | R5 | - |
| i386 | ebx | ecx | edx | esi | edi | ebp | - |
| ia64 | out0 | out1 | out2 | out3 | out4 | out5 | - |
| parisc | r26 | r25 | r24 | r23 | r22 | r21 | - |
| s390 | r2 | r3 | r4 | r5 | r6 | r7 | - |
| s390x | r2 | r3 | r4 | r5 | r6 | r7 | - |
| sparc/32 | o0 | o1 | o2 | o3 | o4 | o5 | - |
| sparc/64 | o0 | o1 | o2 | o3 | o4 | o5 | - |
| x86_64 | rdi | rsi | rdx | r10 | r8 | r9 | - |
Note that these tables don't cover the entire calling convention---some architectures may indiscriminately clobber other registers not listed here.
#define _GNU_SOURCE #include <unistd.h> #include <sys/syscall.h> #include <sys/types.h> #include <signal.h> int main(int argc, char *argv[]) { pid_t tid; tid = syscall(SYS_gettid); tid = syscall(SYS_tgkill, getpid(), tid, SIGHUP); }


{# ikhaya/report_new.html ~~~~~~~~~~~~~~~~~~~~~~ Formular to report a mistake in an article. :copyright: (c) 2013-2019 by the Inyoka Team, see AUTHORS for more details. :license: BSD, see LICENSE for more details. #} {% extends 'ikhaya/base.html' %} {% block breadcrumb %} {{ super() }} {{ macros.breadcrumb_item(article.subject, article|url) }} {{ macros.breadcrumb_item(_('Reports'), article|url('reports')) }} {{ macros.breadcrumb_item(_('New report'), article|url('report_new')) }} {% endblock %} {% block content %}
{% trans link=article|url('reports') %} Describe here briefly the discovered mistake. Please make sure that the mistake was not already reported. {% endtrans %}
{% call macros.outer_form(csrf_token(), form, button_visible=False) %} {% endcall %} {% if preview %}


Lists
Unordered list
C language
JavaScript language
Ruby language
Ordered list
C language
JavaScript language
Ruby language
Description list
HTML
- This is for structure of web page
CSS
- Styling of web page
JavaScript
- Behavior of web page


St. Xavier's College, Mumbai(Autonomous)
Department Of History
NAME:
AGE:
E-MAIL:
UID No.:
Play Quiz
Welcome to the Quiz!!
Select any one answer from the choices
1.Which of the following is called 'Gift of Nile'?
India
China
Egypt
Nigeria
2.When were the first olympics held?
776 BC
780 BC
540 BC
600 BC
3.Vasco da Gama reached India in the year?
1495
1488
1489
1498
4.Magna Carta was signed in the year?
1210
1220
1215
1225
Submit


Meet The team
Mohammad ALtaeab
Mechanical Engineer fresh graduate from Jordan University of Since and Technology
Issa Salman
Issa Salman Mechatronics engineer My Goal is to be robots simulator and Software developer
Yousef Jariry
A Software engineering fresh graduate from Hashemite University
Farouk Ibrahim
Farouk Ibrahim Civil Engineer graduated from Middle East University
Reem Khalil
Civil engineer fresh graduate from LTUC
Tareq Sharaia
Tariq Sharaia Mechanical Engineer graduated from Mutah University
Ahmad AbuRezeq
Graduated from Alzaytoonah University Major Computer science


gh pages HTML css js
2014-07-29
###gh-pagesHTMLcss_js###
- HTML, css and js is enoght for creating a web site. In github this is determental in any gh-pages intended to create.
- There are several templates specifically available, useed in gh-pages
- For simple markdown template this template was used. https://github.com/aplib/markdown-site-template
- Final usage of this web site was selected based on its demonstration


---
title: KULA
subject: Order Created
preview_text: Your Order has been created.
logo_path: /uploads/logo_wordmark_tealblue.svg
logo_width: 215
logo_height: 22
header_path: /headers/default.html
header_background_color: '#ffffff'
footer_path: /footers/default.html
show_order_details: true
show_pricing_details: false
---
Order Received
Hi [[ first_name ]],
Thank you for placing order [[ order_id ]].
Your order will be confirmed shortly, we will notify you by email.
The credit card used has been authorized. dfgdf gfh Your card will be charged once your purchase has been confirmed.
{% if page.show_order_details or page.show_pricing_details %}
Order Details:
{% endif %}
{% if page.show_order_details %}
{% include order-details.html %}
{% endif %}
{% if page.show_pricing_details %}
{% include pricing-details.html %}
{% endif %}


Table of Contents
{{TOC}}This manual contains notes of varying importance that should be read with care; i.e.:
Important
Contains essential information regarding handling the product, the product itself or a specific part of the documentation.
Note Provides supplementary information regarding handling the product, the product itself or a specific part of the documentation.
All names identified by ® are registered trademarks of Siemens AG. The remaining trademarks in this publication may be trademarks whose use by third parties for their own purposes could violate the rights of the owner.
We have reviewed the contents of this publication to ensure consistency with the hardware and software described. Since variance cannot be precluded entirely, we cannot guarantee full consistency. However, the information in this publication is reviewed regularly and any necessary corrections are included in subsequent editions.


Game Builder: Intro to Scripting (API v2)
While it's perfectly possible to make an entire game in Game Builder without writing a single line of code, writing code will allow you to create much richer and more interactive experiences that wouldn't be possible just with built-in objects and cards.
Anyway, enough about the benefits of code :) If you are reading this, it's because you are already interested in writing some code and you know that coding is fun, so let's get right to it.
Fundamentals
Any game in Game Builder is made up of two fundamental things: terrain and actors. Terrain means the ground and any blocks, ramps, corners, etc, that you have placed with the Construct tool. Everything else is an actor. For example, in the scene below, can you tell what's terrain and what's an actor?
Answer: there are 5 actors in the scene:
- The slime on the left
- The rock
- The tree
- The "Hey there" text box
- The player!
The ground and the metal platform in the center are terrain.
Let's add some code!
Let's start simple. Create a new game and put just a slime on the ground. Not a very exciting game (yet!), I know, but let's start simple.
You can see that the slime moves around. That's a behavior that comes with it by default because wandering around aimlessly sounds like something a slime would do, but for our purposes let's remove it.
Select the Logic tool and click on the slime. Then look for its Enemy AI panel and remove the Wander Around cards.
You should now have a slime that's standing still.
Now comes the fun part. Use the Logic tool again on the slime, but this time click the Code tab at the top.
And we get... a Javascript editor!
What you are doing now is you're creating a new card that we will later use on the slime (but you could use it on anything else).
Cards are what give behaviors to actors. Each card corresponds to a code module like the one you're seeing right now.  There is no magic, only code!
First, rename your new card by clicking on the card title field (it's the text field highlighted in red the image above). Name it something interesting, say, MY CARD.
Ok, now delete all the sample code you see in the editor and replace it by this:
export function onTick() { log("Tick..."); }
Now click the Save button above the coding area in order to apply your changes.
What happens now?
You have just created a card. You have not yet added that card to the slime. This is what we will do next.
Adding the card to the slime
Now go back to the Logic tab (make sure the slime is selected).
In the Custom panel, click the dotted rectangle to add a new card. Then drag your fancy new My Card card from the list into the slot:
Don't let your hopes up too much yet, this example isn't going to do anything, but it will show you an important feature.
When you drop the card, your slime is now printing "Tick..." to the console every time the onTick() function is called.
Where is this console, you ask? Just press the ~ key to view it. On a US keyboard, that's the key at the top-left of the keyboard below the ESC key, normally just to the left of the 1 key. You should now see a little console appear at the top of the screen, filled with "Tick..." messages. Close it by pressing ~ again.
You now know how to print logs. It may not sound exciting, but it will be useful later when you're debugging something and need to print stuff out!
Ok, now let's change that code to do something more interesting than printing a log. Ready? Replace it with this:
export function onTick() { spin(2); }
Now click the Run button above the coding area in order to apply your changes to your slime.
What do you get? Yes, a spinning slime:
How does this happen? We are calling the spin API function, which spins an actor with the given rotational speed. In this case we set it to 2 radians/second. Prefer to use degrees/second? No worries, just use the handy degToRad function.
export function onTick() { // Spin at 45 degrees/second. spin(degToRad(45)); }
Ok, enough spinning for now. Let's talk about moving around. This slime is going places.
Movement
Now try replacing the code by this:
export function onTick() { moveForward(1); }
What do you get? If your answer was runaway slime, you are right! The slime just moves forward infinitely:
The moveForward API call moves the actor forward with the given speed. In this case we required a speed of 1 meter/second.
So what exactly does forward mean? Well, it's the direction the slime is currently looking.
To be more precise, we need to do a quick intro to coordinate systems (also called spaces).
Brief intro to spaces
Briefly stated, a space or a coordinate system is a way to interpret a set of (x, y, z), coordinates. By convention, the X value means "to the right", Y means "up" and Z means "forward". With relation to what? Well, that's exactly what we have to always clearly state!  (ok, maybe it would be the second question, just after "why are you giving me orders?").
A space is just a formalization of this. A space is just a notion of which way is right/up/forward and with relation to what:
The names we normally give to these arrows are:
- X axis - red arrow. This points to the right.
- Y axis - green arrow. This points up.
- Z axis - blue arrow. This points forward.
Look at the slime in this scene. The three arrows on it represent the slime's actor space. That's what the slime thinks of as "forward" (blue arrow), "right" (red arrow) and "up" (green arrow). Same thing with the lion: that's the lion's actor space. That's what it thinks of as forward/right/up. It's different than the slime's notion. It's a different space.
The third space or coordinate system in the picture (the one in the center) is what we call world space. It's a global coordinate system that everyone agrees on. When something is given in world coordinates that's the space that it's represented on. So if I say "go two steps in the world forward direction", everyone in the scene would agree about in which direction to go. World space is the same for everyone.
When we are talking about world space, instead of saying "forward", "backward", "right" and "left", we tend to say north, south east and west instead, because that makes it more clear that we are talking about world space. So if I say "everyone, move two steps north", everyone would go in the same direction regardless of where they are facing.
Note: if you have used other game engines and graphics programs before, you may have noticed that some of them like to think of Z as pointing "backward" instead of "forward". We use forward because we think it's more intuitive this way.
Moving in actor space
We already saw moveForward() in the last section. Now we can be more precise about it: moveForward() moves forward in actor space, so the actor will go in the direction that it's looking at.
Just like we have moveForward(), we also have moveBackward(), moveRight(), moveLeft(), moveUp() and moveDown(). Those are all in actor space, so relative to where the actor is looking.
Let's combine spin() with moveForward now for an interesting effect:
// My script export function onTick() { spin(1); moveForward(1); }
What do you get now? Yes, a slime that runs around in circles:
Why does this happen? Think about what happens on every tick: the slime turns a little bit, then takes a tiny step forward. The fact that it's turning means that "forward" is different every time, so the net effect is that it runs around in a circle. Neat, right?
Moving in world space
All of those move in actor space. Now let's see how we'd move in world space. Suppose for example that you wanted to move the slime north, no matter where it's facing. In this case you can use the moveGlobal function, which moves an actor with a world-space velocity:
export function onTick() { // Move north. moveGlobal(vec3(0,0,1)); }
Note that the slime is moving towards the world's north direction regardless of where it's looking. That's why it moves sideways.
Interactions
What's a fundamental thing that is missing in the examples we've done so far? Hint: it's pretty fundamental in games.
Answer: player interaction! So far, the player has done nothing but watch the slimes move, turn, etc. Let's change that now. For example, let's make the slime change color when it collides with something.
For that, we need to introduce a fundamental concept: messages.
A message is just a packet of information that gets sent from the engine to an actor, or from an actor to another actor. The message tells the actor that something happened, and gives the actor a chance to react to it. The code that reacts to a message is called the message handler function.
You have been using messages already! Guess what: Tick is a message, so when you write your onTick function, you are in fact handling the Tick message. The tick message gets delivered to every actor on every tick.
Another message that the engine delivers to actors automatically is the Collision message, which indicates that another actor has collided with it. Let's try to write a handler for that message and see what happens.
Go back to your slime and edit My Card. Replace the code with this:
export function onCollision() { // Make it blue. setTint(0, 0, 1); }
We set things up so that when the slime hits another actor, it will set its color to blue.
Try it out. When you bump against the slime, it turns blue.
Great, right?
Gate: first try
Let's use our new skills to make a gate that opens when you bump into it. Place a gate between some terrain blocks like this:
Now, use the Logic tool on the gate and remove its built-in IF-THEN panel, because it will interfere with our example. We just want a plain gate!
Now let's try to naively implement a script that opens the gate when you bump into it. Make a new card (or reuse the card you already had on the slime) and put it on the gate. Write this code on the card:
export function onCollision() { // Open the gate by moving the the left a bit moveLeft(1); }
It says "if I collide with something, then move left". Sounds right, doesn't it? Well... almost. Look at what happens:
As you can see, the gate moves left with a speed of 1 meter/second only while the player is colliding with it. If you stop colliding with the gate, it stops.
This happens because the onCollision message gets delivered every frame only while the gate is colliding. After it stops colliding, it is no longer delivered, so your moveLeft call doesn't execute, hence the gate stops moving.
How could we implement a gate that opens smoothly all the way, without needing the player to continually bump against it?
Well, for that, the gate needs to remember that it's currently in the "opening" state. For that, we need memory!
Memory
Memory means a set of values that an actor or a card remembers. You can store variables in memory so you can access them later. It also gets included in the save file, so whatever values you store are persisted if you save the game and load it again.
There are two levels of memory:
- Card memory: This is the memory that's private to your card on this actor. It is not shared with other cards, and not shared with other actors. This is the recommended place to put most of your state, unless you need to share that state between cards.
- Actor memory: This is the memory that belongs to the actor as a whole, and is shared by all the cards that exist on the same actor. This is accessible through the mem global. Use this sparingly, since what you write here can overwrite what other cards have written.
Let's use card memory to create a smoother gate. When the player bumps into it, we will store a variable in card memory called triggered (it could be called anything else, it's just a variable!), and it will represent the fact that the gate has been triggered by the user.
Then, instead of opening the gate only while it's being collided against, we will use the onTick function to slowly open it if the triggered variable is set to true.
To access the card's memory, simply use the card object:
export function onTick() { if (card.triggered) { moveLeft(2); } } export function onCollision() { card.triggered = true; }
Much better, right? What is happening in this code is:
- onTick gets called every frame. But we don't do anything because card.triggered hasn't been set yet. So the gate stays closed.
- The player bumps into the gate.
- onCollision now gets called on the gate.
- We set card.triggered to true.
- onTick continues to get called every frame, but now that card.triggered is set, we call moveLeft(2) That function moves the actor to its left with a speed of 2 meters/second.
Resetting the game
You may have noticed something weird in the previous example. If you reset the game (press Ctrl+R), the gate will immediately open again as if you had triggered it. Why? This happens because memory is not reset automatically.
To ensure that things return to their initial state, you have to implement onInit to reset any memory that you use to a known initial state.
So here is our corrected code:
// onInit is called every time the game is reset: export function onInit() { card.triggered = false; } export function onTick() { if (card.triggered) { moveLeft(2); } } export function onCollision() { card.triggered = true; }
This ensures that when the game is reset, the variable triggered starts with the value of false.
There is still something weird... the gate moves infinitely to the left! Why? There is no stopping condition. Once triggered is set to true, it's never reset.
What we want is to reset it after, say, 1 second. To do this, we can send ourselves a "delayed message" to remind ourselves to reset it:
export function onInit() { card.triggered = false; } export function onTick() { if (card.triggered) { moveLeft(2); } } export function onCollision() { card.triggered = true; // Remind ourselves to stop in 1 second. sendToSelfDelayed(1, "StopIt"); } export function onStopIt() { card.triggered = false; }
Now the gate stops after 1 second of motion.
Properties
When you're designing cards, it's a good strategy to make them as reusable as possible. Don't over-optimize a card for that one particular actor. Say, for instance, you need to make a slime that turns blue for 5 seconds when the player hits it. If the "blue" and "5 seconds" are hard-coded into the card's code, what happens when you need a slime that turns red for 4 seconds instead?
That's what properties are for.
This card, for example, could declare two properties: the color to use, and the duration, and then implement its logic in terms of these properties:
export const PROPS = [ propColor("Color"), propNumber("Duration", 3) ]; export function onInit() { // Start green. setTint(0, 1, 0); } export function onCollision() { // Bump! Change to the requested color. setTintColor(props.Color); // Remind ourselves to change back to green. sendToSelfDelayed(props.Duration, "RestoreColor"); } export function onRestoreColor() { setTint(0, 1, 0); }
Users of the card (you!) will now be able to assign its properties:
The more flexible you make your cards, the more you will be able to reuse them in different actors and contexts!
Sending messages to other actors
Now let's do a more complicated example: a button that launches a rocketship.
There are 2 actors in this example: the rocketship and the button. Hitting the button will cause it to send a "Launch" message to the rocketship. The rocketship, upon receiving that message, will start to go up slowly.
So let's build the scene first:
Nothing fancy. Ok, now let's start with the code for the ship:
// Ship script export function onTick() { // If rocket was launched, move up at 2 units/second. if (card.launched) { moveUp(2); } } // This gets called when we receive the "Launch" message // (sent by the button). export function onLaunch() { card.launched = true; } export function onInit() { card.launched = false; }
Notice how the rocket is programmed to just sit there doing nothing until the card.launched variable is set to true, at which point on every tick it will call moveY to move up at 2 units/second.
When the rocket receives the Launch message (which the button will send, as we will show next), then it sets the card.launched variable to true, causing the motion to begin.
So here is what we write for the button:
// Declare the "rocket" property of this script, of type Actor: export const PROPS = [ propActor("rocket") ]; // This gets called when the player collides with the button. export function onCollision() { // Tell rocket to launch. send(props.rocket, "Launch"); }
There is a funny bit we haven't seen before. This thing:
export const PROPS = [ propActor("rocket") ];
This indicates that this script has an actor property that can be set. This is similar to other properties we saw before (propNumber and propColor), but the value of this property is a reference to another actor.
To assign it, go to the card on the button, and click on the field. You can then select the rocket to set the value of that field, and from that point on you can refer to the rocket from your card as props.rocket.
This is used in onCollision, in which we use the send function to send a message to the rocket. The message is simply Launch, which causes the rocket's onLaunch function to be called, which itself causes the rocket to start going up.
Here is the result:
What's Next
Now that you know the fundamental of how scripting works, you can take a look at the API reference for a full list of functions supported by the API. Happy coding!


| MPI_GROUP_SIZE(group, size) | |
| IN group | group (handle) |
| OUT size | number of processes in the group (integer) |
int MPI_Group_size(MPI_Group group, int *size)
MPI_GROUP_SIZE(GROUP, SIZE, IERROR)
int MPI_Group_rank(MPI_Group group, int *rank)
MPI_GROUP_RANK(GROUP, RANK, IERROR)
int MPI_Group_translate_ranks (MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)
MPI_GROUP_TRANSLATE_RANKS(GROUP1, N, RANKS1, GROUP2, RANKS2, IERROR)
MPI_PROC_NULL is a valid rank for input to
MPI_GROUP_TRANSLATE_RANKS, which returns
MPI_PROC_NULL as the translated rank.
int MPI_Group_compare(MPI_Group group1,MPI_Group group2, int *result)
MPI_GROUP_COMPARE(GROUP1, GROUP2, RESULT, IERROR)
INTEGER GROUP, SIZE, IERROR
{ int MPI::Group::Get_size() const (binding deprecated, see Section Deprecated since MPI-2.2
) }
MPI_GROUP_RANK(group, rank) IN group group (handle) OUT rank rank of the calling process in
group, or
MPI_UNDEFINED if the process is not a
member (integer)
INTEGER GROUP, RANK, IERROR
{ int MPI::Group::Get_rank() const (binding deprecated, see Section Deprecated since MPI-2.2
) }
MPI_GROUP_TRANSLATE_RANKS (group1, n, ranks1, group2, ranks2) IN group1 group1 (handle) IN n number of ranks in ranks1 and
ranks2 arrays (integer) IN ranks1 array of zero or more valid ranks in group1 IN group2 group2 (handle) OUT ranks2 array of corresponding ranks in group2,
MPI_UNDEFINED
when no correspondence exists.
INTEGER GROUP1, N, RANKS1(*), GROUP2, RANKS2(*), IERROR
{ static void MPI::Group::Translate_ranks (const MPI::Group& group1, int n, const int ranks1[], const MPI::Group& group2, int ranks2[]) (binding deprecated, see Section Deprecated since MPI-2.2
) }
This function is important for determining the relative numbering of the
same processes in two different groups. For instance, if one knows the
ranks of certain processes in the group of MPI_COMM_WORLD, one might want
to know their ranks in a subset of that group.
MPI_GROUP_COMPARE(group1, group2, result) IN group1 first group (handle) IN group2 second group (handle) OUT result result (integer)
INTEGER GROUP1, GROUP2, RESULT, IERROR
{ static int MPI::Group::Compare(const MPI::Group& group1, const MPI::Group& group2) (binding deprecated, see Section Deprecated since MPI-2.2
) }
MPI_IDENT results if the group members and group order is
exactly the same in both groups. This happens for instance if
group1 and group2 are the same handle.
MPI_SIMILAR results if the group members are the same but the order is
different. MPI_UNEQUAL results otherwise.
Up: Group Management
Next: Group Constructors
Previous: Group Management
Return to MPI-2.2 Standard Index
Return to MPI Forum Home Page
(Unofficial) MPI-2.2 of September 4, 2009
HTML Generated on September 10, 2009


Hi everyone, I’m Lena Groeger, a developer/designer/journalist at ProPublica. Last year I worked with my colleagues Michael Grabell and Howard Berkes of NPR on a project about insurance. It sounds boring, but it turned out to be one of our most popular data visualizations ever.
I’m going to tell you about 5 things I learned in the process.
The investigation was about workers compensation. In the US, workers get money if are injured on the job, but the system has been slowly destroyed over the last few decades, which we wrote a big long story about.
A bizarre aspect to this horrible situation is that for workers who suffer a serious injury, the difference between being ok and total disaster depends almost entirely on where you live. Your arm, for example, could be worth $50,000 in one state, and $500,000 in another. There are basically no federal standards to how much money you get for injured limbs.
We wanted to visualize this absurd discrepancy.
So, here we go.
To begin, this was what our data looked like. Each state has a “schedule of benefits”, which is basically a big list of body parts and how much money you’d get for them: arms, legs, hands, big toe, etc.
Some of these state laws are just embarrassingly out of date – for example Connecticut’s law still has a provision for “incurable imbecility”, which may have meant something in 1910 but is now just offensive. This what we were dealing with.
So while we were calling each state and collecting all of these schedule of benefits, someone mentioned that these body part lists reminded them of the famous “Angus Beef Chart” that you might see at a butcher shop. Right, you’ve seen these, in one form or another.
We thought, aha! What if we turned our data into a literal human beef chart? What could go wrong?
But now the technical challenge. I needed a way to programmatically size each of 17 different body parts for all 50 states. So I was trying to think of other techniques out there for resizing weird but recognizable shapes.
Well, a cartogram does this. In the same way that a cartogram distorts geography according to data, I could just distort limbs based on dollar figures.
Turns out Mike Bostock had already built a cartogram that resizes each state but keeps it anchored to its center. Surely this would work if I just swap out states with limbs.
But I also needed to be able to adjust all the little feet and arms and hands, so I used this force-directed network of states, and just applied it to my little limb person.
But then things got tricky.
For my early experiments I used a cartoony person.
But when I swapped out a proportional human figure…
…. things got nightmarish and horror-film-worthy very quickly.
I should’ve probably guessed since the only other example I’ve seen is the homunculus man appears in your biology textbook. this is what your body looks like to your brain.
Ok so, back to the cartoon.
It was at this point that I sent a few screenshots to Alberto Cairo, just for for fun. Here’s what he had to say about this. We decided to keep going anyways, without his blessing, at our own peril. (It’s ok, he gave me permission to use this email, he has now praised the graphic).
This was the form we settled on, also a bit more gender-neutral.
But then we got to another wrinkle. After hands, feet, thumb, etc we also had data for EYES.
Eyes, it turns out…. are terrifying.
This doesn’t get better when I add the rest of the body
Or make the eyes outlined.
So, we went back to the original, and decided to include eyes as symbols.
This was a fortuitous choice, because at the last minute we also decided to add in data on testicles, and thus avoided a whole other conundrum.
We ended up telling this story a number of ways. To show how states compared to each other, we used a small multiples comparison across all states. But to show how a specific state compared to the national average, we let you click to see a side-by-side view.
We also made an animated gif to share on social media, and did super well.
Now, this story was tragic. That’s nothing really new at ProPublica, as one reader pointed out to us in 2010.
But that doesn’t mean that all aspects of all our stories needs to be sad. Or, even if WE stay gloomy, it doesn’t mean other news outlets won’t find the humor. Gawker came up with this incredible headline all by themselves.
Another funny story: a few weeks after the project was over, I ran into this poster in a sea-faring/pirate themed bar.
Once again, inspiration is everywhere.
Thanks!


{{name}}
{{ run_id }}
Summary
{{level_counts | safe}}
Types of Actions Taken
{{info_counts | safe}}
Warning Types
{{warning_counts | safe}}
Error Types
{{error_counts | safe}}
Items Processed Succesfully
{{info_df | safe}}
Items Skipped Due to a Warning
{{warnings_df | safe}}
Items Skipped Due to an Error
{{errors_df | safe}}


import {MatSelectModule} from '@angular/material/select';
MatSelect
Selector: mat-select
Exported as: matSelect| Name | Description |
|---|---|
@Input('aria-label')
|
Aria label of the select. |
@Input('aria-labelledby')
|
Input that can be used to specify the |
@Input()
|
Function to compare the option values with the selected values. The first argument is a value from an option. The second is a value from the selection. A boolean should be returned. |
@Input()
|
Whether to center the active option over the trigger. |
@Input()
|
Whether ripples are disabled. |
@Input()
|
Whether the component is disabled. |
@Input()
|
Object used to control when error messages are shown. |
@Input()
|
Whether checkmark indicator for single-selection options is hidden. |
@Input()
|
Unique id of the element. |
@Input()
|
Whether the user should be allowed to select multiple options. |
@Input()
|
Classes to be passed to the select panel. Supports the same syntax as |
@Input()
|
Width of the panel. If set to |
@Input()
|
Placeholder to be shown if no value has been selected. |
@Input()
|
Whether the component is required. |
@Input()
|
Function used to sort the values in a select in multiple mode.
Follows the same logic as |
@Input()
|
Time to wait in milliseconds after the last keystroke before moving focus to an item. |
@Input()
|
Value of the select control. |
@Output()
|
Event emitted when the select panel has been toggled. |
@Output()
|
Event emitted when the selected value has been changed by the user. |
|
A name for this control that can be used by |
|
User-supplied override of the trigger element. |
|
Tabindex to which to fall back to if no value is set. |
|
Whether the select has a value. |
|
Whether the component is in an error state. |
|
Whether the select is focused. |
|
All of the defined groups of options. |
|
Combined stream of all of the child options' change events. |
|
All of the defined select options. |
|
Panel containing the select options. |
|
Whether or not the overlay panel is open. |
|
The currently selected option. |
|
Trigger that opens the select. |
|
The value displayed in the trigger. |
| close | |
|---|---|
|
Closes the overlay panel and focuses the host element. |
| focus | |
|---|---|
|
Focuses the select element. |
|
| Parameters | |
|
options? FocusOptions
|
|
| open | |
|---|---|
|
Opens the overlay panel. |
| toggle | |
|---|---|
|
Toggles the overlay panel open or closed. |
| updateErrorState | |
|---|---|
|
Updates the error state based on the provided error state matcher. |
MatSelectTrigger
Allows the user to customize the trigger that is displayed when the select has a value.
Selector: mat-select-trigger
MatSelectChange
Change event object that is emitted when the select value has changed.
| Name | Description |
|---|---|
|
Reference to the select that emitted the change event. |
|
Current value of the select that emitted the event. |
MatSelectConfig
Object that can be used to configure the default options for the select module.
| Name | Description |
|---|---|
|
Whether option centering should be disabled. |
|
Wheter icon indicators should be hidden for single-selection. |
|
Class or list of classes to be applied to the menu's overlay panel. |
|
Width of the panel. If set to |
|
Time to wait in milliseconds after the last keystroke before moving focus to an item. |
MAT_SELECT_SCROLL_STRATEGY
Injection token that determines the scroll handling while a select is open.
const MAT_SELECT_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
MAT_SELECT_CONFIG
Injection token that can be used to provide the default options the select module.
const MAT_SELECT_CONFIG: InjectionToken<MatSelectConfig>;
MAT_SELECT_TRIGGER
Injection token that can be used to reference instances of MatSelectTrigger
. It serves as
alternative token to the actual MatSelectTrigger
class which could cause unnecessary
retention of the class and its directive metadata.
const MAT_SELECT_TRIGGER: InjectionToken<MatSelectTrigger>;


{% extends "ONS.html" %} {% set mainClasses = "govuk-main-wrapper--l" %} {% from "panel/macro.njk" import govukPanel %} {% block content %}
We’ve sent your query to our Contact Centre agent. You will get a reply within 48 working hours.
They will contact you either to confirm your request, or to ask for more information.


{% extends "base.html" %} {% block title %}
Medieval catalogues > BENEDICTINES > Peterborough > Books given by Abbot Alexander of Holderness (1222-6)
{% endif %}4 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


Day 2
After an entire day spent nursing a migraine, and another working full tilt at the day job, the extent of my coding today consisted of creating a new branch for managing changes to this blog. Woo.
Day 1
Finally getting around to starting 100 days of code. After two horribly busy months at the day job, I can finally spend some time this weekend coding. I am starting with a very basic static site, with the hopes that it will improve with time. The main goal for today was to get this page up and running on GitHub Pages using a custom domain. Thankfully, this process was pretty painless, thanks to Porkbun Domains (mainly chosen for adorable pig logo.)


title = "Volunteers" url = "/volunteers" layout = "default" is_hidden = 0 robot_index = "index" robot_follow = "follow" == use Hmones\Conference\Models\Volunteer; public function onStart(){ $this['volunteers'] = Volunteer::orderBy('name','asc')->get(); } ==


The mobile app allows to browse the almost 3,100 Open Access Data and Document Repositories integrated in the CHAIN-REDS project’s Knowledge Base, presented either through geographic maps or tables. Tapping on a marker on a map or on an element of a table, one gets redirected to the corresponding repository in order to search inside it.
The app also allows to use the CHAIN-REDS Semantic Search Engine to search across the more than 30 million resources contained in the Knowledge Base and enriched by means of Semantic Web technologies. For each record found, a short description of the corresponding resource is provided. Tapping on an element of the list, one can access a detailed view with direct links to the document and, if existing, to the related data.
This app has been developed by:


20 July 1998
Disease Outbreak Reported
Uganda, where cholera is endemic, is still suffering from a major outbreak which started at the end of 1997. Regular reports to WHO continue to show high numbers of cases with case fatality rates ranging from 4% to 5.5 % in different regions. At the end of June 1998 a total of 38,697 cases and 1,576 deaths had been officially reported since the beginning of the outbreak. The total number of affected districts is now 39, covering a large part of the country. Most of the neighbouring countries have also been affected by major cholera outbreaks since late 1997 and continue to report cases.


haskell-jp / code-review #5
Previous
Top
はなかず
2018-08-30 03:24:31 +0900
@はなかず has joined the channel
mrsekut
2018-09-03 00:12:37 +0900
@mrsekut has joined the channel
2018-09-22 00:03:21 +0900
@ has joined the channel
takumaw
2018-09-29 13:34:14 +0900
@takumaw has joined the channel
podhmo
2018-10-13 06:42:30 +0900
@podhmo has joined the channel
kyusuke
2018-11-10 11:33:22 +0900
@kyusuke has joined the channel
fumieval
2018-11-12 11:06:18 +0900
@fumieval archived the channel
Previous
Top


In the method descriptions “I” stands for index type and “T” or “Ts” stand for data type(s)
Visitors are all defined in files include/DataFrameStatsVisitors.h, include/DataFrameMLVisitors.h and include/DataFrameFinancialVisitors.h. Also see test/data_frame_tester.cc for example usage.
There are some common interfaces in most of the visitors. For example the following interfaces are common between most (but not all) visitors:
get_result() It returns the result of the visitor/algo.
pre() It is called by DataFrame each time before starting to pass the data to the visitor. pre() is the place to initialize the process
post() It is called by DataFrame each time it is done with passing data to the visitor.
Random generators are a set of convenient routines to generate random number.
For the definition and defaults of RandGenParams, see this document and file DataFrameTypes.h
These are currently arithmetic operators declared in include/DataFrame.h. Because they all have to be templated, they cannot be defined as redefined built-in operators.
template<typename DF, typename ... Ts> inline DF df_plus(const DF &lhs, const DF &rhs); template<typename DF, typename ... Ts> inline DF df_minus(const DF &lhs, const DF &rhs); template<typename DF, typename ... Ts> inline DF df_multiplies(const DF &lhs, const DF &rhs); template<typename DF, typename ... Ts> inline DF df_divides(const DF &lhs, const DF &rhs);These arithmetic operations operate on the same-name and same-type columns on lhs and rhs. Each pair of entries is operated on, only if they have the same index value.
Although Pandas has a spot-on interface and it is full of useful functionalities, it lacks performance and scalability. For example, it is hard to decipher high-frequency intraday data such as Options data or S&P500 constituents tick-by-tick data using Pandas.
Another issue I have encountered often is the research is done using Python, because it has such tools as Pandas, but the execution in production is in C++ for its efficiency, reliability and scalability. Therefore, there is this translation, or sometimes a bridge, between research and executions.
Also, in this day and age, C++ needs a heterogeneous data container.
Mainly because of these factors, I implemented the C++ DataFrame.
I welcome all contributions from people with expertise, interest, and time to do it. I will add more functionalities from time to time, but currently my spare time is limited.
Views were added in the second wave. It is a very useful concept with practical use-cases. A view is a slice of a DataFrame that is a reference to the original DataFrame. It appears exactly the same as a DataFrame, but if you modify any data in the view, the corresponding data point(s) in the original DataFrame will also be modified.
There are certain things you cannot do in views. For example, you cannot add to delete columns, extend the index column, ...
For more understanding, look at this document further and/or the test files.
Visitors are the mechanism to run statistical algorithms. Most of DataFrame statistical algorithms are in “visitors”. Visitor is the mechanism by which DataFrame passes data points to your algorithm. You can add your own algorithms to a visitor functor and extend DataFrame easily. There are two kinds of visitation mechanisms in DataFrame:
Random generators were added as a series of convenient stand-alone functions to generate random numbers (it covers all C++ standard distributions). You can seamlessly use these routines to generate random DataFrame columns.
See this document and file RandGen.h and dataframe_tester.cc.
The DataFrame library is “almost” a header-only library with a few boilerplate source file exceptions, HeteroVector.cc and HeteroView.cc and a few others. Also there is DateTime.cc.
Starting from the root directory;
include directory contains most of the code. It includes .h and .tcc files. The latter are C++ template code files (they are mostly located in the Internals subdirectory). The main header file is DataFrame.h. It contains the DataFrame class and its interface. There are comprehensive comments for each public interface call in that file. The rest of the files there will show you how the sausage is made.
Include directory also contains subdirectories that contain mostly internal DataFrame implementation.
One exception, the DateTime.h is located in the Utils subdirectory
src directory contains Linux-only make files and a few subdirectories that contain various source codes.
test directory contains all the test source files, mocked data files, and test output files. The main test source file is dataframe_tester.cc. It contains test cases for all functionalities of DataFrame. It is not in a very organized structure. I plan to make the test cases more organized.
Using plain make and make-files
Go to the root of the repository, where license file is, and execute build_all.sh. This will build the library and test executables for Linux flavors
Using cmake
Please see README file. Thanks to @justinjk007, you should be able to build this in Linux, Windows, Mac, and more


handheld and circle the world
Let's the Top
Reaching the top of the goal requires struggle and sacrifice. Like the journey of life too?
Prepare Your Plan
Start all equipment and body conditions to be able to reach the target you want to reach.
Set Goals
Before climbing, you must set a goal first, want to reach the top of the mountain or not. Likewise in life.
All About Hobbies
If you want to get or see something amazing, get out of your comfort zone.
Like an Atom
You will feel small and helpless after arriving at the top of the mountain.
Life isn't Alone
Mountain climbing makes you aware, there are many good people in this world who still want to help.


MIT License
Copyright (c) 2017 Mapwize
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Mapwize uses portions of mapbox-gl-native
mapbox-gl-native copyright (c) 2014-2017 Mapbox.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

Mapwize uses portions of AFNetworking
Copyright (c) 2011-2016 Alamofire Software Foundation (http://alamofire.org/)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Mapwize uses portions of Ionicons
Copyright (c) 2016 Drifty (http://drifty.com/)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Mapwize uses portions of Kingfisher
Copyright (c) 2017 Wei Wang
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Mapwize uses portions of MTBBarcodeScanner
Copyright (c) 2016 Mike Buss<EMAIL_ADDRESS>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


The original array library had a somewhat different API. The new array
library can be accessed through the old interface by including
#include "oldarrays.h"
The only slight difference that may be
noticed is that oldarray::size is not an integer, but an object that
converts to an integer. The problem is that overloaded functions may
ge confused.


Toggle navigation
Danni
Login
Sign Up
About Us
Contact
Landing Page Says Hello!


Converting a virtual disk image: VDI to VMDK to a raw loopback file you can mount
By default, VirtualBox creates virtual disk images in a special format called VDI, which is unique to VirtualBox. Disk images are stored in $HOME/.VirtualBox/HardDisks.
You’ll need to convert VDI into another format if you want to run a VirtualBox VM on another virtualization platform, such as VMWare or KVM.
The VMDK virtual disk format is a good choice because even though it originated with VMWare it is supported by other virtualization platforms including VirtualBox and KVM.
VirtualBox enables the conversion using the low-level “VBoxManage clonehd” command:
VBoxManage list hdds # prints a list of disk image UUIDs
VBoxManage clonehd
cd ~/.VirtualBox/HardDisks/
ls -la converted.vmdk
Once you have converted to VMDK you can use qemu-img, a tool bundled with qemu (KVM’s virtualization backend) to further convert VMDK to other formats.
A particularly useful format to convert to is ‘raw’ which you can then mount as a loopback device:
apt-get install qemu
qemu-img convert -f vmdk converted.vmdk -O raw converted.raw
mount -o loop converted.raw /mnt


| Cockpit Guide |
|---|
remotectlremotectl — Remote Access Configuration |
remotectl
{COMMAND} [OPTIONS...]
The remotectl program will configure remote access to the system. Currently it manages cockpit's SSL certificate.
certificate |
Manage Cockpit's SSL certificate. If used without options will check if cockpit has a valid certificate without making any changes.
If any additional arguments are given, they are treated as files that should be combined to create a certificate file. If the combined files validate, they will be saved in the appropriate location using the name of the first file given with the extension changed to .cert. For example: remotectl certificate server.pem chain.pem key.pem will result in |


Romeo and Juliet
by William Shakespeare
Act 5, Scene 2
Additional Information
- Year Published: 1597
- Language: English
- Country of Origin: United States of America
- Source: Shakespeare, W. Romeo and Juliet New York: Sully and Kleinteich
-
Readability:
- Flesch–Kincaid Level: 11.0
- Word Count: 258
- Genre: Tragedy
- Keywords: 16th century literature, british literature, drama, romance, tragedy
- ✎ Cite This
Downloads
SCENE. Friar Laurence's cell.
(Enter FRIAR JOHN)
FRIAR JOHN
Holy Franciscan friar! brother, ho!
(Enter FRIAR LAURENCE)
FRIAR LAURENCE
This same should be the voice of Friar John.
Welcome from Mantua: what says Romeo?
Or, if his mind be writ, give me his letter.
FRIAR JOHN
Going to find a bare-foot brother out
One of our order, to associate me,
Here in this city visiting the sick,
And finding him, the searchers of the town,
Suspecting that we both were in a house
Where the infectious pestilence did reign,
Seal'd up the doors, and would not let us forth;
So that my speed to Mantua there was stay'd.
FRIAR LAURENCE
Who bare my letter, then, to Romeo?
FRIAR JOHN
I could not send it,—here it is again,—
Nor get a messenger to bring it thee,
So fearful were they of infection.
FRIAR LAURENCE
Unhappy fortune! by my brotherhood,
The letter was not nice but full of charge
Of dear import, and the neglecting it
May do much danger.
FRIAR JOHN
Brother, I'll go and bring it thee.
(Exit)
FRIAR LAURENCE
Now must I to the monument alone;
Within three hours will fair Juliet wake:
She will beshrew me much that Romeo
Hath had no notice of these accidents;
But I will write again to Mantua,
And keep her at my cell till Romeo come;
Poor living corse, closed in a dead man's tomb!
(Exit)


[1]
nice picture; reflects like a mirror (even the bezels reflect!!)
[2]
picture, size; the fact that it is dead after 1.5 years


Horizontal forms allow you to use grid row and column classes to get the label beside one another and divide the space between the two.


Stats Tracking - Incoming
The Traffic URL Setting
The Traffic URL setting specifies where your trades should send their traffic. This will need to be a .php or .shtml page of your site so that the necessary stats
tracking code can be embedded and executed. Once you have decided the file type you would like to use, get the appropriate code below.
Code for .php Pages
You have a couple of options when using a .php page for your Traffic URL. The first option requires that PHP be running as an Apache webserver module and uses the
PHP virtual() function. Assuming that you have installed TradeX in the tx directory of your server, the PHP code would look like this:
The second option can be used on any version of PHP and uses the include() function. Assuming that you have installed TradeX in the tx directory of
your server and the page you are including this code in is in the base directory of your site, the PHP code would look like this:
Code for .shtml Pages
Assuming that you have installed TradeX in the tx directory of your server, the SSI tag for a .shtml page would look like this:
Placing the Code
For best results you should place the stats tracking code within the <head> section of your page. For example, on a .shtml page you might use this:
My Site


--- title: (BFBaseCollection) listItems keywords: documentation theme, jekyll, technical writers, help authoring tools, hat replacements last_updated: July 3, 2016 tags: [getting_started] sidebar: matlab_docs_sidebar permalink: bfbasecollection_listitems.html folder: mydoc ---
listItems Returns list of items in the dataset or collection. listItems(OBJ) displays all of the items that reside within a dataset, package or collection in the console. OUT = listItems(OBJ) returns the items in the object as a table with the NAME and ID as column headers. Example: BF = Blackfynn() DS = BF.get('dataset_id') DS.listItems() ITEMS = DS.listItems()
| Access | public |
| Sealed | false |
| Static | false |


|
Stone Mason
0.0.0
(A really bad) C++ Game Engine (that you should NOT use)
|
#include "stms/config.hpp"
#include "GL/glew.h"
#include "GLFW/glfw3.h"
#include "glm/glm.hpp"
#include "glm/gtc/type_ptr.hpp"
#include "glm/gtx/transform.hpp"
#include "stms/logging.hpp"
#include "gl_buffers.hpp"
Go to the source code of this file.
Data Structures | |
| class | stms::GLShaderModule |
| struct | stms::GLUniform |
| class | stms::GLShaderProgram |
| class | stms::GLTexture |
| class | stms::GLFrameBuffer |
| class | stms::GLTexRenderer |
Namespaces | |
| stms | |
| Namespace containing everything StoneMason has to offer! (https://github.com/RotartsiORG/StoneMason) | |
Macros | |
| #define | __STONEMASON_GL_SHADERS_HPP |
| #define | GLEW_STATIC 1 |
| #define | GLFW_INCLUDE_NONE |
Enumerations | |
| enum | stms::GLShaderStage { stms::eVert = GL_VERTEX_SHADER, stms::eFrag = GL_FRAGMENT_SHADER, stms::eComp = GL_COMPUTE_SHADER, stms::eTessCtrl = GL_TESS_CONTROL_SHADER, stms::eTessEval = GL_TESS_EVALUATION_SHADER, stms::eGeo = GL_GEOMETRY_SHADER } |
| enum | stms::GLScaleMode { stms::eNearest = GL_NEAREST, stms::eLinear = GL_LINEAR, stms::eNearMipNear = GL_NEAREST_MIPMAP_NEAREST, stms::eLinMipNear = GL_LINEAR_MIPMAP_NEAREST, stms::eNearMipLin = GL_NEAREST_MIPMAP_LINEAR, stms::eLinMipLin = GL_LINEAR_MIPMAP_LINEAR } |
| enum | stms::GLWrapMode { stms::eRepeat = GL_REPEAT, stms::eMirrorRepeat = GL_MIRRORED_REPEAT, stms::eClampToBorder = GL_CLAMP_TO_BORDER, stms::eClampToEdge = GL_CLAMP_TO_EDGE } |
| #define __STONEMASON_GL_SHADERS_HPP |
| #define GLEW_STATIC 1 |
| #define GLFW_INCLUDE_NONE |


Next: Examples of Style for Semicolon, Previous: Use of Triple Semicolon, Up: Semicolon
Comments that begin with a quadruple semicolon are all aligned to the left margin, and generally contain only a short piece of text that serve as a title for the code which follows, and might be used in the header or footer of a program that prepares code for presentation as a hardcopy document.


PERSONALITY
Section: Linux Programmer's Manual (2)
Updated: 2014-04-15
Index
Return to Main Contents
NAME
personality - set the process execution domain
SYNOPSIS
#include <sys/personality.h>
int personality(unsigned long persona);
DESCRIPTION
Linux supports different execution domains, or personalities, for each
process.
Among other things, execution domains tell Linux how to map
signal numbers into signal actions.
The execution domain system allows
Linux to provide limited support for binaries compiled under other
UNIX-like operating systems.
If
persona
is not
0xffffffff, then
personality()
sets the caller's execution domain to the value specified by
persona.
Specifying
persona
as 0xffffffff provides a way of retrieving
the current persona without changing it.
A list of the available execution domains can be found in
<sys/personality.h>.
RETURN VALUE
On success, the previous
persona
is returned.
On error, -1 is returned, and
errno
is set appropriately.
ERRORS
- EINVAL
-
The kernel was unable to change the personality.
CONFORMING TO
personality()
is Linux-specific and should not be used in programs intended to
be portable.
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- RETURN VALUE
-
- ERRORS
-
- CONFORMING TO
-
This document was created by
man2html,
using the manual pages.
Time: 02:54:46 GMT, September 18, 2014


Massive is a JavaScript benchmark that focuses on large, real-world C++ codebases compiled into asm.js using Emscripten. This is just one pattern of JavaScript among many on the web, but is very important for things like games, and unique in that the generated JavaScript is often very large (much larger than typical JavaScript benchmarks), which is the motivation for a new benchmark.
(Benchmark will take a while to run, and some browsers may become less responsive for part of that time.)
| Benchmark | Raw result |
Scale | What it measures | Normalized score |
|---|
No, it is a work in progress.
The Emscripten benchmark suite developed over time in order to benchmark Emscripten itself, and therefore mainly focused on throughput, and is runnable in both shell and browser. Massive, on the other hand, tests not just throughput but also browser responsiveness and other factors that only make sense when running in a browser.
Main thread responsiveness measures the user experience as a large codebase is loaded. What is tested is whether the main thread stalls as the codebase is parsed and executed for a short while. The score here can be improved by parsing the code off the main thread, for example. This does not measure how much time is spent, but only how responsive or unresponsive the user experience is (how much time is spent is measured by parsing, and to some extent throughput). Technically, we measure responsiveness by seeing if events on the main thread execute at the proper interval (as when the main thread stalls, it stalls both the user experience and other events).
Throughput measures how fast a large computational workload runs. This is what is typically measured by benchmarks. Massive's throughput tests focus on very large real-world codebases.
Parsing measures how long (in wall time) is spent to get a codebase ready to execute. This measures how much time passes between adding a script tag with that code and being able to call the code (this may or may not cause a user-noticeable pause, depending on whether it is parsed on or off the main thread; main thread responsiveness tests that aspect). Note that the term "parsing" is used because of the usual distinction between "parsing" (everything that is done before actually running the code) and "running" (actually executing the code), but it is possible a JS engine may not use this time to parse (it may defer parsing) or it may do other things (like start to compile the code).
Variance measures how variable the frame rate is in an application that needs to run in each frame (this is important in things like games, which much finish all they need every 1/60 of a second, in order to be smooth). Specifically, we run many frames and then calculate the statistical variance and worst case. Note that one VM might have a much faster overall frame rate than another, but also more variance: in general, given two VMs with the same average, the one with less variance is "better" since it's smoother. But given a different mean, things are less clear (perhaps we are happy to get some average slowdown in order to reduce variance which can cause noticable but rare pauses?). Hence we measure variance separately from throughput (which is a measurement of the total speed, and is proportional to the average).


Jankenpopp & Zombectro are running the thing,
the Mighty Doctor House is hosting the thing.
animate.css | CSS animations
www.piskelapp.com | Pixel Art and Animated Sprites editor
GameBoy-Online | GameBoy Color emulator written in JavaScript
WebPd | Run your Pure Data patches on the web.
threejs.org | JavaScript 3D library
codemirror.net | text editor implemented in JavaScript for the browser
codef.santo.fr | Canvas Oldshool Demo Effect Framework
www.asciimation.co.nz | Star Wars Asciimation
jGravity | A jQuery Gravity Plugin
howler.js | Modern Web Audio Javascript Library
html5bytebeat | Bytebeats in HTML5
html5-wolfenstein3D | HTML5 Wolfenstein 3D
PiSaucer | The person who add this to github, heroku, and to Bored At School Right Now Inc
If we forgot you, we're sorry, you can ask us a link
Xtra thanks
David Liebhardt was here 4 teh Lulz


Handling large JSON in python, or how I still can't come up with a sexy blog title
A recent project I was involved in included refactoring a bespoke bin-packing algorithm that had, through continual design changes and rework, become unwieldy and unmaintainable. The decision was made to spin it out into a separate microservice (from the main monolithic python webserver). We took this approach for a few reasons:
- By forcing separation from the database we hoped to encourage cleaner implementation
- Greater extensibility thanks to separate release cycles
- General separation of concerns
- A pinch of curiosity
- Plenty of other microservice benefits that I won't go into here 1
However, during the switch, we ran into a few problems around memory and performance when consuming a large amount of json data from an HTTP response, and inserting it into the database. Here's how that went down.
The beginning
In our brand new microservice, our bin-filling algorithm resulted in an incredibly large amount of bins, all containing 10 to 20 or so small structures. The data returned from the service looked something along the lines of
{
"bins": [
{
"bin_uuid": "00000000-0000-0000-0000-000000000000",
"items": [
{
"item_uuid_a": "00000000-0000-0000-0000-000000000000",
"item_uuid_b": "00000000-0000-0000-0000-000000000000",
},
... * ~10
]
},
... * ~100,000 (one bin per showing for two weeks in a large cinema chain)
]
}
Once this data (~100mb) returned to the main monolith, we set about processing it. There isn't much to do with it other than put it straight into our database, so we went through several iterations. First, the totally naive approach that we initially prototyped
...
for bin in data['bins']:
for item in bin['items']:
db.Session.add(db.Thing(
uuid=item['item_uuid_a'],
other_uuid=item['item_uuid_b'],
bin_uuid=bin['bin_uuid']
))
db.Session.commit()
# Fetching request took 6.33s
# Loading JSON took 5.56s
# Processing took 14.19s
# Committing took 57.72s
# Entire process took 83.81s
We generated a 20,000 bin test data set and threw in some straightforward time logging, and the results weren't pretty. It took 10 seconds to retrieve and json dump the data, then another half a minute to process it, and then 75 seconds to actually commit to the database. This clearly wasn't going to scale nicely up to five times the data-set, so what could we do? Luckily, SQLAlchemy provides us with a few avenues of attack.
The SQL
Firstly, SQLAlchemy 1.0 provided some brand new bulk operations, which seemed perfect for our usecase. Plugging them in was pretty straightforward, too.
things = []
for bin in data['bins']:
things += [
db.Thing(
uuid=item['item_uuid_a'],
other_uuid=item['item_uuid_b'],
bin_uuid=bin['bin_uuid']
)
for item in bin['items']
]
db.Session.bulk_save_objects(things)
# Entire process took 66.92s
Closer to the bone still, we can get rid of a lot of the ORM constructs by looking at SQLAlchemy core. The ORM adds a lot of cruft around making objects more useable and more aligned with OO patterns, so by getting away from that and closer to the core ORM we hoped to cut out a lot of time.
bins = []
things = []
for i, bin in enumerate(data['bins']):
things += [
{
'uuid': item['item_uuid_a'],
'other_uuid': item['item_uuid_b'],
'bin_uuid': bin['bin_uuid']
}
for item in bin['items']
]
db.engine.execute(
db.Thing.__table__.insert(),
things
)
# Entire process took 58.39s
We're getting better, but it's still a lot longer than I'd like! - and 80% of the time is hitting the DB. Luckily, we're using Postgres, which has the delightful COPY FROM command, designed for populating large swathes of homogenous data (as opposed to the much more flexible ANSI SQL insert statement). It takes in a delimited filelike object and an array of column names, and pipes them straight into the database.
string_io = io.StringIO()
for bin in data['bins']:
for item in bin['items']:
# write a tab separated file to the stringio
string_io.write(
'\t'.join([
item['item_uuid_a'],
item['item_uuid_b'],
bin['bin_uuid']
]) + '\n'
)
# rewind
string_io.seek(0)
connection = db.engine.raw_connection()
cur = connection.cursor()
cur.copy_from(
string_io, # filelike obj
'thing', # table name
sep='\t', # separator
columns=['uuid', 'other_uuid', 'bin_uuid']
)
connection.commit()
connection.close()
# Fetching request took 6.12s
# Loading JSON took 5.59s
# Processing took 0.26s
# Copy From took 8.06s
# Entire process took 20.03s
A huge saving! We've gone from 72 seconds of processing down to just 8.3 seconds! We weren't too enthusastic about mucking about with raw cursors and TSVs, but the ten-fold performance increase is undeniably huge, so we decided to refocus our efforts on improving the JSON handling.
The JSON
It's still taking 11 seconds from firing off the request (in our harness, the other service was just loading the json from disk each time), and we'd like to get that down.
The first obvious step is to improve how we parse the data. ujson is a blisteringly fast json library
resp = requests.get('http://<IP_ADDRESS>:8080/filled_bins')
data = ujson.loads(resp.text)
# Fetching request took 6.87s
# Loading JSON took 1.08s
# and now with the raw filelike rather than storing all in memory as a string
resp = requests.get('http://<IP_ADDRESS>:8080/filled_bins', stream=True)
data = ujson.load(resp.raw)
# Fetching request took 7.03s
# Loading JSON took 0.59s
Instant win! But for the raw file pointer, I had to pass stream=True into the request, and that started to pique my interest. Our bin filling service has some pretty straightforward pseudocode - for bin in bins, for widget in widgets: bin.fill(widgets). Then those filled bins just sit waiting for the rest to be constructed before being returned to the monolith, and processed one by one. Could this be improved?
The Request
TBC...


Gets an IIS application as an Application
object.
Get-IisApplication [-SiteName] <String> [[-VirtualPath] <String>] [<CommonParameters>]
Uses the Microsoft.Web.Administration
API to get an IIS application object. If the application doesn't exist, $null
is returned.
The objects returned have two dynamic properties and one dynamic methods added.
ServerManager { get; }
- The ServerManager
object which created the Application
object.CommitChanges()
- Persists any configuration changes made to the object back into IIS's configuration files.PhysicalPath { get; }
- The physical path to the application.Beginning with Carbon 2.0.1, this function is available only if IIS is installed.
| Name | Type | Description | Required? | Pipeline Input | Default Value |
|---|---|---|---|---|---|
| SiteName | String | The site where the application is running. |
true | false | |
| VirtualPath | String | The name of the application. Default is to return all applications running under the website |
false | false |
Get-IisApplication -SiteName 'DeathStar`
Gets all the applications running under the DeathStar
website.
Get-IisApplication -SiteName 'DeathStar' -VirtualPath '/'
Demonstrates how to get the main application for a website: use /
as the application name.
Get-IisApplication -SiteName 'DeathStar' -VirtualPath 'MainPort/ExhaustPort'
Demonstrates how to get a nested application, i.e. gets the application at /MainPort/ExhaustPort
under the DeathStar
website.


OnePlus Black Friday sales include €130 discount on 7 Pro, free cases
by MichailOnePlus is kicking off their Black Friday sales with a broad range of discounts on accessories and several offers on the OnePlus 7 Pro and 7T series.
In Europe, the 7 Pro is getting a sweet €130/£100 discount and now starts at €599/£549. OnePlus is also throwing in a free Nylon Bumper case on the house. You’ll have to add the ‘2019BF’ discount code at the checkout. The OnePlus 7T and 7T Pro on the other hand get a free protective case.
Those in the US can scoop up the 8/256GB OnePlus 7 Pro for $549 instead of the regular $699. There’s also a $150 discount on the 8/256GB OnePlus 6T which comes in at $449 and also gets a free Nylon Bumper case. Additionally you can get up to 50% off on other OnePlus accessories. All promotions are live on OnePlus.com and are available from November 21 through December 9.


--- permalink: /slides/II2019/lecture11.html ---
A quick guide to Lerp~✨Lerp is used to blend between two things!It has three inputs: ( a, b, t )a = start valueb = end valuet = how far we should go from start to end, as a percentageHere it is in action!⚡blending a value, position, color and an angle! pic.twitter.com/LdA69fLI8N— Freya Holmér 🔜 IndieCade Europe (@FreyaHolmer) September 23, 2019
A quick guide to Lerp~✨Lerp is used to blend between two things!It has three inputs: ( a, b, t )a = start valueb = end valuet = how far we should go from start to end, as a percentageHere it is in action!⚡blending a value, position, color and an angle! pic.twitter.com/LdA69fLI8N


Apache Flink is maintained, improved, and extended by code contributions of volunteers. We welcome contributions to Flink, but due to the size of the project and to preserve the high quality of the code base, we follow a contribution process that is explained in this document.
Please feel free to ask questions at any time. Either send a mail to the dev mailing list or comment on the Jira issue you are working on.
IMPORTANT: Please read this document carefully before starting to work on a code contribution. Follow the process and guidelines explained below. Contributing to Apache Flink does not start with opening a pull request. We expect contributors to reach out to us first to discuss the overall approach together. Without consensus with the Flink committers, contributions might require substantial rework or will not be reviewed.
If you have a good idea for the contribution, you can proceed to the code contribution process. If you are looking for what you could contribute, you can browse open Jira issues in Flink’s bug tracker, which are not assigned, and then follow the code contribution process. If you are very new to the Flink project and want to learn about it and its contribution process, you can check the starter issues, which are annotated with a starter label.
Create a Jira ticket or mailing list discussion and reach consensus
Agree on importance, relevance, scope of the ticket, discuss the implementation approach and find a committer willing to review and merge the change.
Only committers can assign a Jira ticket.
Implement the change according to the Code Style and Quality Guide and the approach agreed upon in the Jira ticket.
Only start working on the implementation if there is consensus on the approach (e.g. you are assigned to the ticket)
Open a pull request and work with the reviewer.
Pull requests belonging to unassigned Jira tickets or not authored by assignee will not be reviewed or merged by the community.
A committer of Flink checks if the contribution fulfills the requirements and merges the code to the codebase.
[hotfix]
pull request, without a Jira ticket.
The first step for making a contribution to Apache Flink is to reach consensus with the Flink community. This means agreeing on the scope and implementation approach of a change.
In most cases, the discussion should happen in Flink’s bug tracker: Jira.
The following types of changes require a [DISCUSS]
thread on the<EMAIL_ADDRESS>Flink mailing list:
Do not open a Jira ticket for these types of changes before the discussion has come to a conclusion. Jira tickets based on a dev@ discussion need to link to that discussion and should summarize the outcome.
Requirements for a Jira ticket to get consensus:
If a change is identified as a large or controversial change in the discussion on Jira, it might require a Flink Improvement Proposal (FLIP) or a discussion on the dev mailing list to reach agreement and consensus.
Contributors can expect to get a first reaction from a committer within a few days after opening the ticket. If a ticket doesn’t get any attention, we recommend reaching out to the developer mailing list. Note that the Flink community sometimes does not have the capacity to accept all incoming contributions.
Once all requirements for the ticket are met, a committer will assign somebody to the Assignee
field of the ticket to work on it.
Only committers have the permission to assign somebody.
Pull requests belonging to unassigned Jira tickets will not be reviewed or merged by the community.
Once you’ve been assigned to a Jira issue, you may start to implement the required changes.
Here are some further points to keep in mind while implementing:
Considerations before opening a pull request:
mvn clean verify
is passing on your changes to ensure that all checks pass, the code builds and that all tests pass.Considerations before or right after opening a pull request:
Code changes in Flink are reviewed and accepted through GitHub pull requests.
There is a separate guide on how to review a pull request, including our pull request review process. As a code author, you should prepare your pull request to meet all requirements.
The code will be merged by a committer of Flink once the review is finished. The Jira ticket will be closed afterwards.


Unique mandalas procedurally generated in WebAssembly
Click on one of the mandalas for more options. Refresh the page to get a fresh set of mandalas.