The trap has been set. Now, it's time for someone to fall into it. Or, the heroes have discovered the evil plan, but there's nothing they can actually do about it until the plan is in motion.
Hero: We wait. (or "Now we wait." or "We wait. What else can we do?")
If it's the hero having this exchange, it's often followed by a Time-Compression Montage. If it's the villain, we generally cut directly to our heroes approaching the trap.
Note that if someone gets tired of waiting and attempts pre-emptive action, the consequences are usually dire.
Used to be commonly rendered as "And now we play the Waiting Game...", but this line is now almost never played straight. Take this example from The Simpsons:
[Several seconds of silence]
Homer: Ah, the Waiting Game sucks. Let's play Hungry Hungry Hippos.
The Waiting Puzzle is the video game version. Compare The Stakeout.
Examples:
- Said by veteran Igarashi to rookie Rin in salvage manga Wa Ga Na Wa Umishi. Rin whines about the team having fun when people are in trouble.
- Lampshaded in the Neighbourhood Cluck Dragon Ball Z abridged parody of the first movie, [1]
Piccolo: It's a rule of Dragon Ball: We wait.
- The Ultimates: Hawkeye has Hulk on his sight, armed with an arrow with the antidote, but he'll shoot at "the right moment". Fury urges him to stop the nonsenses and fire already.
- Invoked in the penultimate confrontation of The Blues Brothers: Bob and the Good Ole Boys have bought tickets to the Blues Brothers' show, and must now wait for the band to actually come on stage.
- Subverted by the police, who must also wait, but in their case, it's because the officer in charge wants to see the band play before they arrest them.
- While planning to drug the tiger in the bathroom, the character Alan is set up to deliver this line in "The Hangover".
- In Harry Potter when Hermione and Harry see their past selves in Hagrid's hut, Harry wants to rush in and capture Peter Pettigrew who is hiding as Scabbers, Ron's rat. Hermione says they must wait until actions they take won't disrupt what for them are past events. She and Harry are forced to wait until the group comes back out of the tunnel, knowing that Pettigrew gets away and Lupin will change into his werewolf form.
- Since this was a Stable Time Loop world, it wasn't just that they shouldn't - logically, they couldn't.
- In Star Trek (2009), Nero says this when his ship arrives at the coordinates where Ambassador Spock is going to enter the alternate timeline. In this case, they only have to wait for about a minute.
- The Doom novels had this trope invoked frequently from the second book through the fourth book, generally expressed as "Hurry up and wait."
- Many Sherlock Holmes stories include Holmes, Watson, and Lestrade waiting for the criminal to fall in Holmes' trap.
- In A Song of Ice and Fire Illyrio Mopatis' plan to restore the Targaryens has involved over 15 years of this. As changing events required repeated extensions of the wait time, Lord Connington gets tired of it and goes off-script, invading Westeros with Aegon without reaching Danaerys.
- In Larry Niven's Protector, the transmogrified super-intelligent Brennan is taking the hero on a sub-light Ramscoop ride to Alpha Centauri. The hero is riding in a stasis chamber, so that the years-long journey will pass in an instant for him. Mid-way through the trip, though, a battle with a Pak ramscoop forces them to throw the stasis chamber at their attackers, thus depriving the hero of a means of waiting out the remaining years to their destination. Brennan asks, "Just how much boredom can you stand?"
- In part 2 of Life of Pi, this was one of Pi's strategies for dealing with Richard Parker. He was originally going to outlast and wait for the tiger to die of starvation/thirst. But eventually after realizing the tiger would be desperate enough to attack him, as well as hearing it offer a sound of friendship, Pi decides to keep the tiger alive on the lifeboat, and establish an Alpha-Omega relationship with it to protect himself.
- Edgedancer (a novella of The Stormlight Archive): Lift tells this to Wyndle as they begin The Stakeout. This being said, she gets tired of it pretty quickly and goes to sleep, telling Wyndle to hold the fort and wake her up if anything happens.
- Our Miss Brooks: Miss Brooks stakes out a burglar in the episode "The Burglar".
- Used for comedy on 'What It's Like Being Alone', on which this is Emo Teen Aldous' favourite pastime. When asked what they're waiting for, she replies "Well, eventually, we die."'
- The Doctor Who episode "Vincent and the Doctor" shows why the Doctor fails at this trope.
- The producers of The Amazing Race are famous for subjecting their contestants to a variation of this trope. At the beginning of many legs of the race we're told "Racer A and Racer B who arrived first at 1:53 p.m. will now depart at 1:53 a.m." And with the last place team we're told "Racer M and Racer N who arrived at 4:14 p.m. will now depart at 4:14 a.m." Then the teams race to the airport to find that the first available flight to their destination doesn't leave until noon. Or they race to some local tourist trap that doesn't open until 10 a.m.
- Lost Season Five: The characters have become Trapped in the Past, which is still an improvement over random, erratic and increasingly frequent time travel they've been experiencing. When asked "Now What?", Sawyer replies "We wait".
- Magic: The Gathering has the aptly named card Standstill.
"Take your time."
- In Final Fantasy X, when Tidus asks what they should do while Yuna is praying to the Fayth, Kimahri answers: "Pick spot. Shut up. Wait."
- Final Fantasy XV has this exchange at the beginning of the game, after getting the Regalia into Hammerhead for repairs.
Ignis: And now we play the waiting game.Prompto: Never liked that game.Noctis: Never any good at it, either.
- NES action-adventure/rail shooter The Guardian Legend has this advice for opening a locked door: "Wait, wait forever..."
- The Mother in Dragon Age: Origins Awakening reacts to the loss of Kal'Hirol with this and a fine, healthy and educational evil laugh.
- In Sluggy Freelance Hereti-Corp's overall plan for finding Dr. Steve's base lab is to wait until Torg (one of only three or four living people who's been there) gets scared enough of Oasis that he goes to the lab looking for a tool or weapon to stop her with. May be the best strategy, since their two attempts to force the information out of Torg both ended with a lot of Hereti-Corp personnel getting killed.
- The Fate Spiders, after they make some alterations to the Web of Fate, sit back to see whether their efforts save the world, since the actions of character(s) who are Immune to Fate make even their long term predictions somewhat uncertain.
- And the Sentient Cream Pies With Great Comic Timing.
Banana Cream Pie: What do we do, Chocolate?Chocolate Cream Pie: We bide our time, Banana. We bide our time.
- Jerkcity uses this after they seek help from a god of dicks.
- Salacia, the leader of The Omniscient Council of Vagueness watching Dethklok in Metalocalypse is constantly telling his underlings, "We Wait," "We Watch," "It's too soon," or some variation thereof. When two of them actually try to do something, one gets killed, and the other eventually gets brainwashed. Salacia wants Dethklok to bring about the prophesied Metalocalypse, and thus prevents his Illuminati-like group from taking action to prevent it.
- Subverted by Mr. Burns on The Simpsons.
Mr. Burns: I could crush him like an ant, but it would be too easy. No, revenge is a dish best served cold. I'll bide my time until ...  I'll just crush him like an ant.
- A Family Guy manatee joke has Peter as Zan of the Wonder Twins. He/Jayna get called on a mission. She leaves, he turns into a tampon and jumps into her purse:
Now we play the waiting game.
- An episode of Phineas and Ferb revolves around the main characters sitting around and waiting to see exactly how the titular characters inventions keep disappearing right before their mother gets home. They even break out into a song about how they're waiting for something to happen.
- In The Awesomes Dr. Malocchio proclaims that with the first stage of his plan complete all they have to do now is wait. Then one of his minions suggests that instead they go get sushi and come back, which he agrees is a better plan.
- Danger Mouse: In "The Great Bone Idol," Count Duckula has found the Great Bone Idol. Greenback has opened it and released the imprisoned bark of Cerebrus eminating from a bone which is calling upon all the dogs in the world. With the bone in his hand, Duckula asks what's next. "We wait," says Greenback. Duckula then tosses the bone back into the idol and it locks back up. Greenback, Duckula and Stiletto are now overwhelmed by dogs with no way of controlling them.
- The idiom "Hurry up and wait"
- Used a lot in the theatre and music worlds, where you need to be in a specific place at a certain time for a certain time, often well before you actually have anything to do there. Most calls for rehearsals or performances are at least half an hour before a player is needed on stage.
- Airports, where you're supposed to be there two hours ahead of time for the security stuff, and spend an hour and 45 minutes waiting on it. (Unless, of course, you show up on time, in which case it'll take two hours...)
- Half of your life seems to be that. Because sometimes there is nothing better to do. Still waiting for that reply to your application? Too bad, the employer's having lunch right now.
- Every single armed force ever. Especially if you are traveling via military airlift. Show up two hours early, and then expect to sit on the plane for another two hours before the engines start.
- From Chuck Norris Facts: "Chuck Norris doesn't sleep. He waits."


Small Batch means carefully handcrafted food in an artisan fashion.
Small Batch means carefully handcrafted food in an artisan fashion.
We all love food!
With a hint of Middle Eastern flare and a zest for modern fusion cuisine, Zaher's Small Batch perfectly suits Date Nights, Family Dinners and DIY Home Catering for when you're entertaining guests!
Further, we want to share our passion for food with you, and in the convenience of your own home... for a fraction of the cost of dining out!
Simply click on the "Order Now" button at the top of your screen or follow the menu options below!
Simply click on the "Order Now" button at the top of your screen or follow the menu options below!
From this point, we need some basic information so we can contact you when your order is ready!
Since our supply is partially dependant on the local butchers we source and a baker who makes our fresh bread daily, we require 24 hours to complete your order. As everything is freshly prepared and vacuum sealed, you have a week to pick it up! The efficiency behind this system helps us keep our costs low for you, when we don't waste good food!
There are NO CANCELLATIONS once the order has been placed so please, double check your tasty selection!
Our ONEBox selection is our higher line of par-prepared take home meals!
Our BBQBox concept is just as cool, and a bit cheaper.
Our ONEBox selection is our higher line of par-prepared take home meals! All of these meals are prepared fresh to order and vacuum sealed for you to enjoy in the comfort of your own home! Instructions are included and all ONEBox courses are prepared as easily as dropping the vacuum sealed packages in boiling water for a few minutes, or grilling!
Our BBQBox concept is just as cool, and a bit cheaper. In every meal, you get: a side salad, grilling veggies, 8oz of meat and even the desserts go on the grill! No mess! Perfect for family dinners, camping or even entertaining large company for your outdoor occasion that you're celebrating!
For large events, please check out our "Live Charcoal Events" section!


LFE Style Guide
4 Documentation
4.1 Document everything
You should use document strings on all visible functions to explain how to use your code.
Unless some bit of code is painfully self-explanatory, document it with a documentation string (also known as docstring).
Documentation strings are destined to be read by the programmers who use your code. Documentation strings are where you should document your API. They should describe how to use the code (including what pitfalls to avoid), as opposed to how the code works (and where more work is needed), which is what you'll put in comments.
Supply a documentation string when defining top-level functions, types, classes, variables and macros. Generally, add a documentation string wherever the language allows.
For functions, the docstring should describe the function's contract: what the function does, what the arguments mean, what values are returned, what conditions the function can signal. It should be expressed at the appropriate level of abstraction, explaining the intended meaning rather than, say, just the syntax. In documentation strings, capitalize the names of Lisp symbols, such as function arguments. For example:
(defun get-area (length width)
"This function calculates the area of a rectangle.
The value of LENGTH should be an integer. The value of WIDTH should be an
integer."
...)
A long docstring may usefully begin with a short, single-sentence summary, followed by the larger body of the docstring.
When you fix a bug, consider whether what the fixed code does is obviously correct or not; if not, you must add a comment explaining the reason for the code in terms of fixing the bug. Adding the bug number, if any, is also recommended.
4.2 Comment Semicolons
Comments are explanations to the future maintainers of the code. Even if you're the only person who will ever see and touch the code, even if you're either immortal and never going to quit, or unconcerned with what happens after you leave (and have your code self-destruct in such an eventuality), you may find it useful to comment your code. Indeed, by the time you revisit your code, weeks, months or years later, you will find yourself a different person from the one who wrote it, and you will be grateful to that previous self for making the code readable.
You must comment anything complicated so that the next developer can understand what's going on. (Again, the "hit by a bus" principle.)
Also use comments as a way to guide those who read the code, so they know what to find where.
- File headers and important comments that apply to large sections of code in
a source file should begin with four semicolons
;;;;
. - You should use three semicolons
;;;
to begin comments that apply to just one top-level form or small group of top-level forms. - Inside a top-level form, you should use two semicolons
;;
to begin a comment if it appears between lines. - You should use one semicolon
;
if it is a parenthetical remark and occurs at the end of a line. You should use spaces to separate the comment from the code it refers to so the comment stands out. You should try to vertically align consecutive related end-of-line comments.
Example:
;;;; Great module description
;;;; ...
(defmodule great-module
(export
(some-useful-function 1)))
...
;;; Comment about function
(defun some-useful-function (useful-argument)
(another-function useful-argument) ; Comment at end of line
(yet-another-fucntion) ; Another one for this line
;; Comment about the next chunk of code at the same level of indentation
...)
...
For all semicolon comments, you should include a space between the semicolon and the text of the comment.
4.3 Grammar and Punctuation
When a comment is a full sentence, you should capitalize the initial letter of the first word and end the comment with a period. In general, you should use correct punctuation.
4.4 Attention Required
You should follow the convention of using TODO
OR XXX
comments for
code requiring special attention. For code using unobvious forms, you must
include a comment.
For comments requiring special attention, such as incomplete code, todo
items, questions, breakage, and danger, include a TODO
OR XXX
comment indicating the type of problem, its nature, and any notes on how it
may be addressed.
The comments begin with TODO
OR XXX
in all capital letters, followed
by the name, e-mail address, or other identifier of the person with the best
context about the problem referenced by the TODO
. The main purpose is to
have a consistent TODO
that can be searched to find out how to get more
details upon request. A TODO
is not a commitment that the person
referenced will fix the problem. Thus when you create a TODO
, it is
almost always your name that is given.
When signing comments, you should use your username or full email address, which ever most readily identifies you. If using github, you can use your github username preceded by the "@" sign. Do not just initials of your name.
Examples:
;; XXX (oubiwann@cogitat.io): Refactor to provide a better API.
Be specific when indicating times or software releases in a TODO
comment
and use YYYY-MM-DD format for dates to make automated processing of such
dates easier, e.g., 2038-01-20 for the end of the 32-bit signed time_t
.
;; TODO (@rvirding): Remove this code after release 1.7 or before
;; 2012-11-30.
For code that uses unobvious forms to accomplish a task, you should include a comment stating the purpose of the form and the task it accomplishes.
4.5 Domain-Specific Languages
You should design your Domain Specific Language to be easy to read and understand by people familiar with the domain.
You must properly document all your Domain Specific Language.
Sometimes, your DSL is designed for terseness. In that case, it is important to document what each program does, if it's not painfully obvious from the context.
Notably, when you use regular expressions (e.g. with the re
module), you
should always put in a comment (usually a two-semicolon comment on the
previous line) explaining, at least basically, what the regular expression
does, or what the purpose of using it is. The comment need not spell out
every bit of the syntax, but it should be possible for someone to follow the
logic of the code without actually parsing the regular expression.


Art can be much more than a rectangular painting on a wall, or a piece of sculpture on a pedestal. Since the early 20th century, art has continued to evolve more forms, many of which cross over old or arbitrary barriers of labels and categories. Like today's music, contemporary art wants to mix forms together, and create entirely new ones. If we ask why, can't we also ask, why not? The main objective, and distinguishing characteristic, of good art, is its expression - what it is "saying." To accomplish this communication, artists need to create freely and question assumptions about art, and about themselves and their audience. Art is ambiguous and subjective. If we ask different persons “what is art” they are going to tell different definitions. For some it can be a picture of a horse, a landscape, the universe or anything else. This means that there is not a correct meaning for art. A great deal of works that are consider like art such as Mona Lisa (see figure 1) have become well known through centuries, and a great deal of people would agree that those works can be considered as art.
Artists can strengthen the will and push people to act. Artists do not think like policy makers or academics people. Artists think from their heart – big, revolutionary and visionary ideas. This is why artists are able to move people to action, thus creates a significant cultural and political contributions.
Art is very important in society because it is an essential ingredient to empowering the hearts of people When activists are showing images of children suffering from poverty or oppression in their campaigns, this is the art pulling the heartstrings of society’s elite and powerful to make changes. When photographers publish the photos of war torn areas, it catches the attention of masses whose hearts reach out for those who need help. When artist create great music and movies, it entertains people around the world. This is art, making a difference in society.
While many can argue or have different point of views, these points reflect and evolve in our understanding of ourselves, each other, and the world we live in:
Art is not what you see, but what you make others see.


I signed up for GitHub to create this website and the whole process seemed incredibly difficult and vague. In this post I’m going to introduce GitHub and really quickly describe signing up, creating a repository, and editing that repository. If you want a more hands on and thorough lesson, you should head over to Code School for their Try Git course.
Introduction to GitHub
Git is a file sharing website. That’s it. But the real power in Git comes from the ability to download, update, and share code easily. Essentially, if there is an open source project that you would like to contribute to, you can “fork” that repository. Then, if you would like to share your changes, you simply submit a “pull request” to the repository’s author. They can see by your profile what you have done and how trustworthy you are.
Also, one bonus of git is their free website hosting (which is where this website is) through GitHub Pages. If you would like to set up a GitHub website, check out this page.
Signing Up for GitHub
Creating a GitHub account is really easy. Just go to https://github.com/ and follow the steps. You’ll also need to download and install git. You might want to use a GUI client, but it is up to you how you want to work with Git. This tutorial will use the command line.
Creating a Repository
The first thing you need to do is to create a repository on your GitHub page by clicking on the little ‘+’ sign in the upper right hand corner. This will take you to a page that will give you options for creating repositories from the command line in the future. You’ll also be given a URL for your repository, which you should copy to the clipboard. Click on the README link to create a readme file in your repository and add some blablabla, then save the changes.
Next, you need to create a local repository. In the terminal, cd
into whatever directory you want to be the parent directory of your local git repository. Once there, type
git clone https://github.com/blablabla
… obviously replacing the url by the one you just copied. This will copy all of the files from your repository on GitHub and intitialize your local repository.
Adding Files to a Repository
Now that you have a repository, let’s learn to make some changes. First, create any kind of file in the local repository you want. Seriously, just save a .txt haiku about your cat, it doesn’t really matter. Now that it is done, type
git status
You should see a red cat_haiku.txt
. This means there is a new file in your local repository that has not yet been staged. What you need to do is add your new file to the staging area. There are several ways to do this, by name, by file type, etc., but one nice one is to just add ALL of the new files:
git add --all
Now if you run git status
again, you’ll see that cat_haiku.txt
is ready to commit. Finally, to commit the changes to the repository, type the following
git commit -m "A message"
where -m "A message"
allows you to include the commit message directly in the command line (try doing this command without it, it is really not fun).
Now, your updated project is saved in the GitHub repository, but it is not yet shared. In fact, the new haiku won’t even show up on your personal page. How will anyone read it!? The last thing you need to do is to push the repository. Type
git push origin master
You’ll be prompted for your username and password. Once that’s done you can celebrate!
 However, I stumbled across this great page that gathers a bunch of useful links into one place. I highly recommend you take a few hours to read and learn about everything Git can do and how to use it.


--- # This file is licensed under the MIT License (MIT) available on # http://opensource.org/licenses/MIT. layout: wallet-platform-container ---
{% translate pagedesc choose-your-wallet %}
{% include helpers/hero-social.html %}{% translate educatetxt choose-your-wallet %}


Task Manager
#
Name
Content
Deadline
IsFinished
{{task.id}}
{{task.name}}
{{task.content}}
{{task.deadline}}
None
Finished
Not finished
X
{{error}}
Create
Change or delete
Add new task.
Name
Content
Describe the task.
Deadline
Set finished or delete task.
ID of the task.


{include file='manage@common/include_meta' /}
{block name="title"}动心阁后台管理{/block}
{include file='manage@common/include_style' /} {include file='manage@common/include_js' /} {block name="custom_head"}自定义meta{/block} {load href="__X-ADMIN__/js/globalConfig.js" /} {block name="header"} {include file='manage@common/tpl_header' /} {/block} {block name="sidebar"} {include file='manage@common/tpl_sidebar' /} {/block} {block name="content"} 内容 {/block} {block name="footer"} {include file='manage@common/tpl_footer' /} {/block} {load href="__X-ADMIN__/js/function.js" /}


Gregor Von Laszewski
Latest
-
Hybrid Reusable Computational Analytics Workflow Management with Cloudmesh Applied to the MLCommons Cloudmask Application
-
In-depth Analysis On Parallel Processing Patterns for High-Performance Dataframes
-
Reusable Hybrid and Multi-Cloud Analytics Service Framework
-
Hybrid Reusable Computational Analytics Workflow Management with Cloudmesh
-
Proceedings of the CyberTraining REU2022 CyberTraining for Students and Technologies from Generation Z
-
AI Benchmarking for Science: Efforts from the MLCommons Science Working Group
-
HPTMT Parallel Operators for High Performance Data Science and Data Engineering
-
Hybrid Reusable Computational Analytics Workflow Management with Cloudmesh
-
Time Series Analysis of Blockchain-Based Cryptocurrency Price Changes
-
Time Series Analysis of Blockchain-Based Cryptocurrency Price Changes
-
Time Series Analysis of Cryptocurrency Prices Using Long Short-Term Memory
-
Time Series Analysis of Cryptocurrency Prices Using Long Short-Term Memory
-
Scientific Impact Report Repository
-
Cybertraining Publications
-
Comprehensive Evaluation of XSEDE's Scientific Impact Using Semantic Scholar Data
-
Using GAS for Speedy Generation of HybridMulti-Cloud Auto Generated AI Services
-
Proceedings: 2021 AI First Engineering
-
AICov: An Integrative Deep Learning Framework for COVID-19 Forecasting with Population Covariates
-
HPTMT: Operator-Based Architecture for Scalable High-Performance Data-Intensive Frameworks
-
HPTMT: Operator-Based Architecture for Scalable High-Performance Data-Intensive Frameworks
-
Scientific Impact Evaluation for XMS
-
Scientific Impact Evaluation for XMS Update
-
Big Data Applications and Analytics -- 534
-
Big Data Applications and Analytics (Lecture Notes)
-
Cloud Clusters with Raspberry Pi's
-
Cloud Computing
-
Cloudmesh Community
-
Intelligent Systems Engineering
-
Linux for Cloud Computing
-
Openstack with Chameloen Cloud
-
Proceedings of Cloud Computing Engineering (2020)
-
Python for Cloud Computing
-
Scientific Writing with Markdown
-
AICov: An Integrative Deep Learning Framework for COVID-19 Forecasting with Population Covariates
-
Towards Automatically Generated Hybrid Multi-Cloud AI Services
-
Cloud Technologies
-
Lecture Notes on Cloud Computing Engineering (2019)
-
Proceedings of Cloud Computing Engineering (2018)
-
Proceedings of Cloud Computing Engineering (2019)
-
Proceedings of Cloud Computing Engineering (2020)
-
Streaming Machine Learning Algorithms with Big Data Systems
-
Human in the Loop Virtual Machine Management on Comet
-
NIST Big Data Interoperability Framework: Volume 8, Reference Architecture Interfaces
-
Handbook of Clouds and Big Data
-
Scientific Impact Evaluation for XMS, Paper Presentation, PEARC'18
-
Scientific Impact Evaluation for XMS
-
Evaluating the Scientific Impact of XSEDE
-
Teaching Big Data and Open Source Software on Chameleon Cloud
-
XMS Scientific Impact
-
Automated sharded mongodb deployment and benchmarking for big data analysis
-
Cloudmesh in support of the NIST Big Data Architecture Framework
-
Comet: Tales from the Long Tail: Two Years In and 10000 Users Later
-
User Managed Virtual Clusters in Comet
-
Peer Comparison of XSEDE and NCAR Publication Data
-
Peer Comparison of XSEDE Publication Data
-
Cloudmesh Resource Reservation
-
TAS View of XSEDE Users and Usage
-
Introduction of the proposed Peers Comparison Method
-
Introduction of the proposed Peers Comparison Method
-
Genomic Sequence Analysis Automation
-
Towards understanding cloud usage through resource allocation analysis on xsede
-
Accessing multiple clouds with cloudmesh
-
The FutureGrid Testbed for Big Data
-
Towards a Scientific Impact Measuring Framework for Large Computing Facilities - a Case Study on XSEDE
-
Performance Metrics and Auditing Framework using Application Kernels for High-performance Computer Systems
-
Co-processing SPMD computation on CPUs and GPUs cluster
-
Contemporary High Performance Computing
-
On-demand Service Hosting on Production Grid Infrastructures
-
Using XDMoD to Facilitate XSEDE Operations, Planning and Analysis
-
Abstract Image Management and Universal Image Registration for Cloud and HPC Infrastructures
-
Comparison of Multiple Cloud Frameworks
-
Supporting Experimental Computer Science
-
Data analytics driven cyberinfrastructure operations, planning and analysis using XDMoD
-
Design of an Accounting and Metric-based Cloud-shifting and Cloud-seeding Framework for Federated Clouds and Bare-metal Environments
-
FutureGrid Image Repository: A Generic Catalog and Storage System for Heterogeneous Virtual Machine Images
-
Analysis of Virtualization Technologies for High Performance Computing Environments
-
Grappling cloud infrastructure services with a generic image repository
-
Simulation of Threat Management of Urban Water Distribution Systems with Grid Workflow
-
eMOLST: A Documentation Flow for Distributed Health Informatics
-
Providing a Green Framework for Cloud Based Data Centers
-
Task scheduling with ANN-based temperature prediction in a data center: a simulation-based study
-
Threat detection in an urban water distribution systems with simulations conducted in grids and clouds
-
Towards building a cloud for scientific applications
-
Towards cloud deployments using futuregrid
-
Towards on Demand IT Service Deployment
-
Workshop on data intensive computing in the clouds-DataCloud
-
Dynamic Provisioned Experiments in FutureGrid
-
Design of the FutureGrid Experiment Management Framework
-
Provide Virtual Machine Information for Grid Computing
-
Rain: Dynamically Provisioning Clouds within FutureGrid
-
Cyberaide Virtual Applicance: On-Demand Deploying Middleware for Cyberinfrastructure
-
Cyberaide onServe: Software as a Service on Production Grids
-
Towards Energy Aware Scheduling for Precedence Constrained Parallel Tasks in a Cluster with DVFS
-
Schedule Distributed Virtual Machines in a Service Oriented Environment
-
Provide Virtual Distributed Environments for Grid computing on Demand
-
Cloud Computing: a Perspective Study
-
Efficient resource management for Cloud computing environments
-
Enabling Energy-Efficient Analysis of Massive Neural Signals Using GPGPU
-
Multicores in Cloud Computing: Research Challenges for Applications
-
Cyberaide Creative: On-Demand Cyberinfrastructure Provision in Clouds
-
Thermal Aware Workload Scheduling with Backfilling for Green Data Centers
-
Towards Thermal Aware Workload Scheduling in a Data Center
-
GreenIT Service Level Agreements
-
Accelerating Partitional Algorithms for Flow Cytometry on GPUs
-
Power-Aware Scheduling of Virtual Machines in DVFS-enabled Clusters
-
Open Grid Computing Environments
-
Experiment and Workflow Management Using Cyberaide Shell
-
09131 Abstracts Collection -- Service Level Agreements in Grids
-
Cyberaide Shell: Interactive Task Management for Grids and Cyberinfrastructure
-
Flexible framework for commodity FPGA cluster computing
-
Grid Virtualization Engine: Design, Implementation and Evaluation
-
Accelerating Time to Scientific Discovery with a Grid-Enhanced Microsoft Project
-
Cyberaide JavaScript: A JavaScript Commodity Grid Kit
-
e-Science Project and Experiment Management with Microsoft Project
-
A cumulus project: design and implementation
-
Accelerating time to scientific discovery with a grid-enhanced microsoft project
-
Grid Computing Environments 2007 Confernce Proceeedings
-
JavaScript Grid Abstractions
-
A Portal for Visualizing Grid Usage
-
Cyberinfrastructure for Contamination Source Characterization in Water Distribution Systems
-
Grid Workflow with the Java CoG Kit
-
GridTorrent Framework: A High-performance Data Transfer and Data Sharing Framework for Scientific Computing
-
Java CoG Kit Workflow
-
Portal-based Knowledge Environment for Collaborative Science
-
The Open Grid Computing Environments collaboration: portlets and services for science gateways
-
Grid Computing Environments 2006 Confernce Proceeedings
-
Collaboratory for Multi-scale Chemical Science (CMCS): Project Final Report.
-
A Batch Import Module for an Empirically Derived Mass Spectral Database
-
An Abstraction Model for a Grid Execution Framework
-
An Adaptive Cyberinfrastructure for Threat Management in Urban Water Distribution Systems
-
An End-to-End System for Organizing, Sharing Raw and Derived Mass Spectrometry Data
-
Comparing mass spectra
-
SAGA: A Simple API for Grid Applications. High-level application programming on the Grid
-
The Enhanced Mass Spectrometry I/O Project
-
The Java CoG Kit Experiment Manager
-
Work coordination for Grid computing
-
Workflow Management Through Cobalt
-
A Repository Service for Grid Workflow Components
-
Quality Assured Ad Hoc Grids
-
Toward Reputable Grids
-
Grid Portal Architectures for Scientific Applications
-
The Grid-Idea and Its Evolution
-
A Grid Certificate Authority for Community and Ad-hoc Grids
-
A Collaborative Informatics Infrastructure for Multi-Scale Science
-
A Model for Quality-of-Service Provision in Service Oriented Architectures
-
Active Thermochemical Tables: Thermochemistry for the 21st century
-
Developing a Distributed and Scalable Foundation for Mass Spectrometry Data
-
Grid portal architectures for scientific applications
-
Grid Workflow -- An Integrated Approach
-
Java cog kit karajan/gridant workflow guide
-
Quality-of-Service Based Grid Communities
-
Workflow Concepts of the Java CoG Kit
-
Toward an Architecture for Ad Hoc Grids
-
An Overview of Grid File Transfer Patterns and their Implementation in the Java CoG Kit
-
Analysis and Provision of QoS for Distributed Grid Applications
-
QoS Support for High-performance Scientific Grid Applications
-
Commodity Grid Kits
-
Abstracting the Grid
-
Gestalt of the Grid
-
Grid Middleware
-
GridAnt: A Client-Controllable Grid Workflow System
-
High-Level Grid Execution Patterns
-
Introduction to Active Thermochemical Tables: Several Key Enthalpies of Formation Revisited
-
Middleware for Communications
-
A Framework for Building Scientific Knowledge Grids Applied to Thermochemical Tables
-
Grid Computing for the Masses: An Overview
-
Metadata in the Collaboratory for Multi-Scale Chemical Science
-
A File Transfer Component for Grids
-
Flow-based Multistage Co-allocation Service
-
Further Refinements of the Bond Dissociation Energy in Water and Hydroxyl Radical Using the Active Thermochemical Tables Approach
-
Commodity Grid Kits - Middleware for Building Grid Computing Environments
-
Java CoG Kit Workflow Concepts for Scientific Experiments
-
QoS guided Min-Min heuristic for grid task scheduling
-
Sourcebook of Parallel Computing
-
A QoS Guided Scheduling Algorithm for the Computational Grid
-
Open Collaborative Grid Services Architecture (OCGSA)
-
A Grid Service-Based Active Thermochemical Table Framework
-
Key Concepts and Services of a Grid Information Service
-
InfoGram: A Peer-to-Peer Information and Job Submission Service
-
The Astrophysics Simulation Collaboratory: A Science Portal Enabling Community Software Development
-
Grid Computing: Enabling a Vision for Collaborative Research
-
Software, Component, and Service Deployment in Computational Grids
-
A CORBA Commodity Grid Kit
-
A Perl Commodity Grid Kit
-
A Unicore Globus Interoperability Layer
-
Community Software Development with the Astrophysics Simulation Collaboratory
-
Features of the Java Commodity Grid Kit
-
GSFL: A workflow framework for grid services
-
Design and Implementation of a CORBA Commodity Grid Kit
-
Multi-Paradigm Communications in Java for Grid Computing
-
The Astrophysics Simulation Collaboratory: A Science Portal Enabling Community Software Development
-
A Greedy Grid - The Grid Economic Engine Directive
-
A High-Throughput X-Ray Microtomography System at the Advanced Photon Source
-
A Java Commodity Grid Kit
-
Designing Grid-based Problem Solving Environments and Portals
-
GOSv2: A Data Definition Language for Grid Information Services
-
GOSv3: A Data Definition Language for Grid Information Services
-
Status of a Bridge between CORBA and Globus
-
Creating and Managing Grid Services
-
Grid-based Asynchronous Migration of Execution Context in Java Virtual Machines
-
CoG Kits: A Bridge between Commodity Distributed Computing and High-Performance Grids
-
Defining schemas for the grid information services
-
LDAP Browser/Editor
-
Mdsml: An xml binding to the grid object specificaction
-
Using Computational Grid Capabilities to Enhance the Ability of an X-Ray Source for Structural Biology
-
A Loosely Coupled Metacomputer: Cooperating Job Submissions Across Multiple Supercomputing Sites
-
Distance Visualization: Data Exploration on the Grid
-
Grid Infrastructure to Support Science Portals for Large Scale Instruments
-
Quasi-Realtime X-Ray Microtomography System at the Advanced Photon Source
-
Real-Time Analysis, Visualization, and Steering of Microtomography Experiments at Photon Sources
-
A Fault Detection Service for Wide Area Distributed Computations
-
A Fault Detection Service for Wide Area Distributed Computations
-
A Computational Framework for Telemedicine
-
Usage of LDAP in Globus
-
Supercomputing Data Analysis with an Example on the APS CATs
-
A Directory Service for Configuring High-Performance Distributed Computations
-
An Interactive Parallel Programming Environment Applied in Atmospheric Science
-
A Parallel Data Assimilation System and Its Implications on a Metacomputing Environment
-
Issues in Parallel Computing
-
Minimal Requirements for a Graphical User Interface for InfoMall Applications
-
Parallelization of MOPAC
-
XPVM: An X window based interface to the PVM
-
Design Issues for the Parallelization of an Optimal Interpolation Algorithm
-
A collection of graph partitioning algorithms
-
Blocked LU factorization on a multiprocessor computer
-
The Parallelization of a Weather Prediction Model
-
Applications Benchmark Set for Fortran-D and High Performance Fortran
-
On the Parallelization of Blocked LU Factorization Algorithms on Distributed Memory Architectures
-
Partitioning a graph with a parallel genetic algorithm
-
Intelligent Structural Operators for the k-way Graph Partitioning Problem
-
A Parallel Genetic Algorithm for the Graph Partitioning Problem


URL Shortener Microservice
This api provides a shortened url for on provided in the a url get request. Practce project by Andrew VanVlack
Example Inputs
https://van-shrt.herokuapp.com/add/https://www.amazon.com/dp/B00X4WHP5E/ref=ods_gw_echo_dualcreative?pf_rd_r=BDHFTM4SM70P7AC7W3YJ&pf_rd_p=5c035c38-b59c-4188-9e58-03b9e628e3e8
https://van-shrt.herokuapp.com/add/https://www.google.com/maps/place/Tin+Shed+Garden+Cafe/@45.5560703,-122.6422033,15z/data=!4m5!3m4!1s0x0:0x1eb070bdecf8f04b!8m2!3d45.5589635!4d-122.6508763
Example Outputs
{ url: https://van-shrt.herokuapp.com/rJiJNl01x }
{ url: http://van-shrt.herokuapp.com/ByfNneAJe }
Node.js source code available on github


Inherited from
DefaultParamsWritable
Inherited from
MLWritable
Inherited from
Transformer
Inherited from
PipelineStage
Inherited from
Logging
Inherited from
Params
Inherited from
Serializable
Inherited from
Serializable
Inherited from
Identifiable
Inherited from
AnyRef
Inherited from Any


Instructions for:
Accepted Symposia Papers
Accepted Workshop Papers
Accepted Contributed PapersSee the following for further details:
Call for Papers (.doc or .pdf)
Call for Symposia (.doc or .pdf)
Accepted Symposia Papers
Symposia Papers accepted for consideration for publication in Philosophy of Science must be submitted directly to the Program Chair by January 15, 2003.
Symposia Papers may be deposited in the Phil-Sci Archive at any time. You will have to register with the archive in order to deposit your paper. Make sure that the paper is listed under the "Conferences and Volumes: Philosophy of Science Assoc. 18th Biennial Mtg - PSA 2002: Symposia" subject heading. You may list the paper under additional subject headings if you wish. Retain your registration and paper information, as you will be able to update your paper after it is deposited.
Accepted Workshop Papers
Workshop Papers may be deposited in the Phil-Sci Archive at any time. You will have to register with the archive in order to deposit your paper. Make sure that the paper is listed under the "Conferences and Volumes: Philosophy of Science Assoc. 18th Biennial Mtg - PSA 2002: Workshops" subject heading. You may list the paper under additional subject headings if you wish. Retain your registration and paper information, as you will be able to update your paper after it is deposited.
Accepted Contributed Papers
Accepted papers will be reviewed for publication in Philosophy of Science and deposited in the Phil-Sci Archive by the Program Committee. Final versions must be submitted directly to the Program Chair by January 15, 2003.


GetGeneratorKind ( )
1. Let _genContext_ be the running execution context.
1. If _genContext_ does not have a Generator component, return ~non-generator~.
1. Let _generator_ be the Generator component of _genContext_.
1. If _generator_ has an [[AsyncGeneratorState]] internal slot, return ~async~.
1. Else, return ~normal~.
GeneratorYield ( _iterNextObj_ )
The abstract operation GeneratorYield with argument _iterNextObj_ performs the following steps:
1. Assert: _iterNextObj_ is an Object that implements the IteratorResult interface.
1. Let _genContext_ be the running execution context.
1. Assert: _genContext_ is the execution context of a generator.
1. Let _generator_ be the value of the Generator component of _genContext_.
1. Assert: GetGeneratorKind() is ~normal~.
1. Set _generator_.[[GeneratorState]] to `"suspendedYield"`.
1. Remove _genContext_ from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
1. Set the code evaluation state of _genContext_ such that when evaluation is resumed with a Completion _resumptionValue_ the following steps will be performed:
1. Return _resumptionValue_.
1. NOTE: This returns to the evaluation of the |YieldExpression| that originally called this abstract operation.
1. Return NormalCompletion(_iterNextObj_).
1. NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation of _genContext_.


rdoc1.9.1(1) rdoc1.9.1(1) NAME rdoc1.9.1 - Generate documentation from Ruby script files SYNOPSIS rdoc1.9.1 [options] [names...] DESCRIPTION Files are parsed, and the information they contain collected, before any output is produced. This allows cross references between all files to be resolved. If a name is a directory, it is traversed. If no names are specified, all Ruby files in the current directory (and subdirectories) are processed. Available output formatters: chm, html, ri, xml For information on where the output goes, use: rdoc --help-output OPTIONS --accessor, -A accessorname[,..] comma separated list of additional class methods that should be treated like 'attr_reader' and friends. Option may be repeated. Each accessorname may have '=text' appended, in which case that text appears where the r/w/rw appears for normal accessors. --all, -a include all methods (not just public) in the output. --charset, -c charset specifies HTML character-set --debug, -D displays lots on internal stuff --diagram, -d generate diagrams showing modules and classes. You need dot V1.8.6 or later to use the --diagram option correctly. Dot is available from <URL:http://www.research.att.com/sw/tools/graphviz/>. --exclude, -x pattern do not process files or directories matching pattern. Files given explicitly on the command line will never be excluded. --extension, -E new=old treat files ending with .new as if they ended with .old. Using '-E cgi=rb' will cause xxx.cgi to be parsed as a Ruby file --fileboxes, -F classes are put in boxes which represents files, where these classes reside. Classes shared between more than one file are shown with list of files that sharing them. Silently discarded if --diagram is not given Experimental. --fmt, -f formatname set the output formatter (see below). --help, -h print usage. --help-output, -O explain the various output options. --image-format, -I gif|png|jpg|jpeg sets output image format for diagrams. Can be png, gif, jpeg, jpg. If this option is omitted, png is used. Requires --diagram. --include, -i dir[,dir...] set (or add to) the list of directories to be searched when satis‐ fying :include: requests. Can be used more than once. --inline-source, -S show method source code inline, rather than via a popup link. --line-numbers, -N include line numbers in the source code --main, -m name name will be the initial page displayed. --merge, -M when creating ri output, merge processed classes into previously documented classes of the name name. --one-file, -1 put all the output into a single file. --op, -o dir set the output directory. --opname, -n name set the name of the output. Has no effect for HTML. --promiscuous, -p When documenting a file that contains a module or class also defined in other files, show all stuff for that module/class in each files page. By default, only show stuff defined in that par‐ ticular file. --quiet, -q don't show progress as we parse. --ri, -r generate output for use by 'ri.' The files are stored in the '.rdoc' directory under your home directory unless overridden by a subsequent --op parameter, so no special privileges are needed. --ri-site, -R generate output for use by 'ri.' The files are stored in a site-wide directory, making them accessible to others, so special privileges are needed. --ri-system, -Y generate output for use by 'ri.' The files are stored in a sys‐ tem-level directory, making them accessible to others, so special privileges are needed. This option is intended to be used during Ruby installations. --show-hash, -H a name of the form #name in a comment is a possible hyperlink to an instance method name. When displayed, the '#' is removed unless this option is specified. --style, -s stylesheet-url specifies the URL of a separate stylesheet. --tab-width, -w n set the width of tab characters (default 8). --template, -T template-name set the template used when generating output. --title, -t text set text as the title for the output. --version, -v display RDoc's version. --webcvs, -W url specify a URL for linking to a web frontend to CVS. If the URL contains a ´%s', the name of the current file will be substituted; if the URL doesn't contain a '%s', the filename will be appended to it. May 2007 rdoc1.9.1(1)


For those of you who are not too familliar with the term EQ it is simply short for emotional quotient otherwise knows as emotional intelligence. Emotional intelligence is the ability to understand manage and make use of your emotions in a postive manner to relieve stress improve your focus, become a better communicater and overcome challenges. There are many benefits of mastering emotional intelligence which can then benefit yourself as well as having an impact on those around you by being able to understand there emotions better.
Below are the five catergories of self awareness:
In short having a high EQ simply just means having a really good ability to have a deep awareness of your own emotions as well as the emotions of others and being able to translate that information to guide your thinking and that of others.
So if you have made it this far you maybe thinking how is EQ different to IQ. Well IQ is simply short for intelligence quotient, it is basically a measure of a persons reasoning ability. It may be used to gauge a persons reasoning ability or a persons ability to utilise informations and logic to answer questions or make predictions.


Probability of {{ crimes38 }} is {{array38}} %
Probability of {{ crimes37 }} is {{array37}} %
Probability of {{ crimes36 }} is {{array36}} %
Probability of {{ crimes35 }} is {{array35}} %
Probability of {{ crimes34 }} is {{array34}} %
Probability of {{ crimes33 }} is {{array33}} %
Probability of {{ crimes32 }} is {{array32}} %
Probability of {{ crimes31 }} is {{array31}} %
Probability of {{ crimes30 }} is {{array30}} %
Probability of {{ crimes29 }} is {{array29}} %
Probability of {{ crimes28 }} is {{array28}} %
Probability of {{ crimes27 }} is {{array27}} %
Probability of {{ crimes26 }} is {{array26}} %
Probability of {{ crimes25 }} is {{array25}} %
Probability of {{ crimes24 }} is {{array24}} %
Probability of {{ crimes23 }} is {{array23}} %
Probability of {{ crimes22 }} is {{array22}} %
Probability of {{ crimes21 }} is {{array21}} %
Probability of {{ crimes20 }} is {{array20}} %
Probability of {{ crimes19 }} is {{array19}} %
Probability of {{ crimes18 }} is {{array18}} %
Probability of {{ crimes17 }} is {{array17}} %
Probability of {{ crimes16 }} is {{array16}} %
Probability of {{ crimes15 }} is {{array15}} %
Probability of {{ crimes14 }} is {{array14}} %
Probability of {{ crimes13 }} is {{array13}} %
Probability of {{ crimes12 }} is {{array12}} %
Probability of {{ crimes11 }} is {{array11}} %
Probability of {{ crimes10 }} is {{array10}} %
Probability of {{ crimes09 }} is {{array09}} %
Probability of {{ crimes08 }} is {{array08}} %
Probability of {{ crimes07 }} is {{array07}} %
Probability of {{ crimes06 }} is {{array06}} %
Probability of {{ crimes05 }} is {{array05}} %
Probability of {{ crimes04 }} is {{array04}} %
Probability of {{ crimes03 }} is {{array03}} %
Probability of {{ crimes02 }} is {{array02}} %
Probability of {{ crimes01 }} is {{array01}} %
Probability of {{ crimes00 }} is {{array00}} %


UNDER CONSTRUCTION: This website is currently under development by the Marine Robotics group at the Australian Centre
for Field Robotics. It is intended to provide an easy to use system that facilitates exploration and
management of AUV data, improved annotation interfaces and access to our suite of machine learning
tools, including clustering, supervised classification and automated percentage cover estimation.
It is still a work in progress, and at this stage we have mainly been focussing on the
annotation interface. There may still be a few bugs and todos, so any feedback and comments would
be greatly appreciated.
Current features/tools:
- Advanced map-based project creation interface. Create projects from AUV deployment(s) using filter search tools on depth, altitude, data or bounding boxes
- Subset images in the project using temporally stratified (every Nth image) or random selection (N random images)
- Set up annotation runs using N random points
- Easy to use annotation interface with searchable tags, zoom tool, marquee multiple select tool, and other useful tools.
- Basic map interface - once you have a dataset selected, you can view the selected project/subset/image on a map.
Proposed future features/tools:
- Data exploration interface: explore all the data and the labels in the system through a map with
the ability to view relevant images and annotation information. Similar to the current IMOS data
portal, but with more information, including image mosaics underlaid, multibeam bathy and
classification/annotation information.
- Spatial sampling techniques for sub-setting images including spatial stratified, GRTS, etc...
- Automated clustering tool to help with selecting images for further analysis
- Supervised classification tools to help automate the labelling of points/pixels and extrapolating percentage coverage estimation.
- Data import and export tools, and reporting tools for summaries and statistics: make it
easy to import existing labeled data from CPCe (and other common programs).
- Ability to export annotation and survey data in formats suitable for further analysis.
- Image brightness and contrast adjustment in image viewer.
About:
- IMOS was established in 2007 and includes participants from all of Australia’s main university and
government research organizations involved in marine science research. IMOS is designed to be a
fully-integrated, national system, observing at ocean-basin and regional scales, and covering physical,
chemical and biological variables.
- IMOS brings together researchers from a variety of institutions and disciplines. Represented within
this group are benthic ecologists, geoscientists, computer scientists and engineers from multiple
institutions who have come together by the shared understanding that a collaborative approach is
essential for effective marine habitat monitoring at a national scale. Collaborators include the
Australian Centre for Field Robotics (ACFR) at Sydney University; the Institute for Marine and
Antarctic Studies (IMAS) at the University of Tasmania; the Sydney Institute of Marine Science (SIMS)
at the University of New South Wales; the Oceans Institute at the University of Western Australia;
CSIRO Marine and Atmospheric Research; and the Australian Institute for Marine Science.
- IMOS is supported by the Department of Industry, Innovation, Climate Change, Science, Research
and Tertiary Education; the National Environmental Research Program Marine Biodiversity Hub; the
Australian Research Council; the Department of Sustainability, Environment, Water, Population and Communities;
the Australian National Data Service (ANDS); NSW DPI Fisheries; Department of Fisheries WA; Department
of Primary Industries, Parks, Water and Environment.


--- layout: post title: Certified scrum master training day 2 ---
Its taken me a couple days or maybe even a week, but here is my mind map from the certified scrum master. I didn't include everything that was spoken about just the key points I found very relevant.
To Zoom in open image in another tab...


8.9. Validating HTML with Multiple Patterns Per MatcherHere's a Java version of the Perl program to validate a subset of HTML (☞ 132). This snippet employs the usePattern method to change a matcher's pattern on the fly. This allows multiple patterns, each beginning with \G, to "tag team" their way through a string. See the text on page 132 for more details on the approach. Pattern pAtEnd = Pattern.compile("\\G\\z"); Pattern pWord = Pattern.compile("\\G\\w+"); Pattern pNonHtml = Pattern.compile("\\G[^\\w<>&]+"); Pattern pImgTag = Pattern.compile("\\G(?i)<img\\s+([^>]+)>"); Pattern pLink = Pattern.compile("\\G(?i)<A\\s+([^>]+)>"); Pattern pLinkX = Pattern.compile("\\G(?i)</A>"); Pattern pEntity = Pattern.compile("\\G&(#\\d+;\\w+);"); Boolean needClose = false; Matcher m = pAtEnd.matcher(html); // Any Pattern object can create our Matcher object while (! m.usePattern(pAtEnd).find()) { if (m.usePattern(pWord).find()) { ... have a word or number in m.group() can now check for profanity, etc ... } else if (m.usePattern(pImgTag).find()) { ... have an image tag can check that it's appropriate ... } else if (! needClose && m.usePattern(pLink).find()) { ... have a link anchor can validate it ... needClose = true; } else if (needClose && m.usePattern(pLinkX).find()) { System.out.println("/LINK [" + m.group() + "]"); needClose = false; } else if (m.usePattern(pEntity).find()) { // Allow entities like > and { } else if (m.usePattern(pNonHtml).find()) { // Other (non-word) non-HTML stuff simply allow it } else { // Nothing matched at this point, so it must be an error. Grab a dozen or so characters // at our current location so that we can issue an informative error message m.usePattern(Pattern.compile("\\G(?s).{1,12}")).find(); System.out.println("Bad char before '" + m.group() + "'"); System.exit(1); } } if (needClose) { System.out.println("Missing Final </A>"); System.exit(1); } Because of a java.util.regex bug causing the "non-HTML" match attempt to "consume" a character of the target text even when it doesn't match, I moved the non-HTML check to the end. The bug is still there, but now manifests itself only in the error message, which is updated to indicate that the first character is missing in the text reported. I've reported this bug to Sun. Until the bug is fixed, how might we use the one-argument version of the find method to solve this problem? ❖ Turn the page for the answer.
8.9.1. Parsing Comma-Separated Values (CSV) TextHere's the java.util.regex version of the CSV example from Chapter 6 (☞ 271). It's been updated to use possessive quantifiers (☞ 142) instead of atomic parentheses, for their cleaner presentation. String regex = // Puts a double quoted field into group(1), an unquoted field into group(2). " \\G(?:^|,) \n"+ " (?: \n"+ " # Either a double-quoted field ... \n"+ " \" # field's opening quote \n"+ " ( [^\"]*+ (?: \"\" [^\"]*+ )*+ ) \n"+ " \" #field's closing quote \n"+ " |# ... or ... \n"+ " # some non-quote/non-comma text ... \n"+ " ([^\",]*+) \n"+ " ) \n"; // Create a matcher for the CSV line of text, using the regex above. Matcher mMain = Pattern.compile(regex, Pattern.COMMENTS).matcher(line); // Create a matcher for "", with dummy text for the time being. Matcher mQuote = Pattern.compile("\"\"").matcher(""); while (mMain.find()) { String field; if (mMain.start(2) >= 0) field = mMain.group(2); // The field is unquoted, so we can use it as is. else // The field is quoted, so we must replace paired double quotes with one double quote. field = mQuote.reset(mMain.group(1)).replaceAll("\""); // We can now work with field ... System.out.println("Field [" + field + "]"); } This is more efficient than the original Java version shown on page 217 for two reasons: the regex is more efficient as per the Chapter 6 discussion on page 271, and a single matcher is used and reused (via the one-argument form of the reset method), rather than creating and disposing of new matchers each time. |


ASAC-Blog
add an article
author
Article Title
Subject
Coding
3D printing
Cyber security
AI
Content
Total Number Of Articles
0


IBM CIO BT/IT (Chief Information Office Business Transformation and Information Technology)
Development Engineer • China • Oct, 2014 - Present
Developing & Deploying critical, cross functional, global projects for IBM BTIT CIO.
- Building PHP back-end server logic
- creating SOAP/RESTful interfaces for mobile
- Implementing Data Migration
- Designing front-end web application
- English Trainer
UNSW IT Center (The University of New South Wales)
Software Engineer - part-time • Dec, 2012 — Jun, 2013
Science,Research,Universities
- Developing campus-wide programs.
- Support multiple systems users and performing general troubleshooting duties.
- Implementing Data Migration
Harbin Human Resources Service Center
IT support • Dec, 2009 — Dec, 2010
Government, public service, Non-Profit
- Technical Support for official website
{% endif %}
{% if site.resume_section_education %}
University of New South Wale, Faculty of Engineering(QS Ranking: 46 • Sydney, Australia)
Master of Information Technology • Sep, 2011 — Sep, 2013
Professional Recognition: Australian Computer Society
- 1. E-commerce (E-Enterprise Project/Service-Oriented Architectures)
- 2. Database Systems Implementation
Harbin Normal University, China
Bachelor of Computer Science • Class Monitor • Sep, 2005 — Sep, 2009
- 1. Enterprise Web and Software Development
- 2. Networking
- 3. Teaching skills (Computer Teacher Certificate)
{% endif %}
{% if site.resume_section_projects %}
SalesConnect
Senior Software Engineer • 2014 — Present
SalesConnect simplifies the way sellers and sales managers work. The application integrated manager roadmapping, seller roadmapping, opportunity management, social, mobile, and analytics capabilities into one modern work environment. Sales teams are now seeing tangible time savings.
- Share seller roadmap data in real-time for manager roll-ups.
- Access one, global source for seller and manager roadmaps and key deals information.
- See integrated roadmaps and comments, Steps to Closure across brands and reduce the need for ad hoc requests.
- Take advantage of robust reporting capabilities.
- Work anytime, anywhere with our mobile capabilities.
- Seamlessly share files and move among Notes, SalesConnect and Connections.
- Make and receive immediate updates on recent client and opportunity events.
- Re-use opportunity and client data for roadmapping and cadence.
Querying and Maintaining a Compact XML Storage
Software Engineer • 2012 — 2013
Our work is motivated by the mobile software development at National ICT Australia and Green Pea Software, in which managing large amount of XML data on mobile devices is mandatory. We thus turn to the problem of finding a compact storage scheme for XML. The flexibility of XML makes finding a scheme which satisfies all these requirements at the same time extremely challenging.
Naïve BayesText Categorization
Software Engineer • Apr, 2012 — Jul, 2012
Keywords: Java, machine learning, algorithm, naïve Bayes’ theorem. I use 18846 News documents to build the application. The 60% of them are learned and the other 40% are tested. The common word list is built and used in the project. The project used the Naïve Bayes classification VNB to predicate a document is more like a certain category
SCEDoodleservice
Software Engineer • Mar, 2011 — Jun, 2011
Web-based poll service. CSEDoodle offers some popular functions and provides a RESTful application programming interface (API). Users easily create new polls that correspond to the content of the Web page can simply pre-fill the CSE-Doodle wizard through an HTML link or an HTML form.
{% endif %}
{% if site.resume_section_skills %}
Language
Mandarin, English (IELTS L8.5 R8 W6.5 S7)
Professional Skills
- OS: Linux(CentOS, RedHat, Ubuntu), Windows
- Language: C, C++, Java(SCJP Band A 2008), Python, PHP
- DB: Oracle, Mysql, DB2
- Tool: Docker, git, Jenkins, Elasticsearch, backbone.js. jQuery.js, Handlebars.js, Boost, Boostrap, Shell
{% endif %}
{% if site.resume_section_recognition %}
Springfield Nuclear Power Plant
Outstanding Achievement • 2010
Awarded for stopping a nuclear meltdown, even though I also started it.
Duff Beer Customer of the year
1997 — 2001, 2003, 2008 — 2012
Honored by Duff Beer for being an outstanding customer several years straight. Qualifications included most beer consumed at a bar, most beer purchased, and most beer ralphed.
Moe's Patron of the Month
12/2001, 8/2004
Specifically this prestigious awarded twice for stopping a robber with my belly.
{% endif %}
{% if site.resume_section_associations %}
Volunteer • 2008 — Present
Organized fund drives and participated in fundraising events for the benefit of families in third world countries without proper access to malt beverages.
Springfield Nuclear Workers Labor Union
Member in Good Standin • 1994 — Present
Founding member of the local nuclear workers labor union.
{% endif %}
{% if site.resume_section_links %}


library(deckgl)
Create a deckgl
instance:
deckgl()
Add a basemap:
deckgl() %>%
add_basemap()
Add any kind of layers:
# Grid layer example
data("sf_bike_parking")
props <- list(
extruded = TRUE,
cellSize = 200,
elevationScale = 4,
getPosition = ~lng + lat,
tooltip = "Count: {{count}}"
)
deckgl(zoom = 11, pitch = 45) %>%
add_basemap() %>%
add_grid_layer(
data = sf_bike_parking,
properties = props
)
deckgl
InstanceThe deckgl
function creates the widget / renderer to which you add layers and other configuration parameters:
rdeck <- deckgl(
latitude = 37.8,
longitude = -122.45,
zoom = 12
) %>%
add_grid_layer(
data = data,
properties = props
)
Due to the generic function add_layer
any kind of layer defined in the deck.gl Layer Catalog is supported. The layer type is chosen via the class_name
parameter, e. g. ScatterplotLayer
or GeoJsonLayer
. Usually you will not use the generic function but one of the add_*_layer
shortcuts instead:
# Generic function
deckgl() %>%
add_layer("ArcLayer", id, data, properties)
# Shortcut function
deckgl() %>%
add_arc_layer(id, data, properties)
The data
parameter can either be an url to fetch data from or a data object. In most cases you will pass an object of type data.frame
to the layers. Use the formula syntax to define data accessors that deck.gl uses to access the properties of the data object:
props <- list(
getPosition = ~lng + lat
# ...
)
sf
Data ObjectsAn object of class sf is a data.frame
with a geometry list-column. Set the layer prop that fetches the geometry to the geometry list-column of your sf
object:
# Example: PolygonLayer
props <- list(
getPolygon = ~geometry
# ...
)
With add_source
you can add a source to the widget that can be used accross layers:
data("bart_stations")
deckgl() %>%
add_source("bart-stations", bart_stations) %>%
add_scatterplot_layer(
source = "bart-stations",
getPosition = ~lng + lat,
# ...
) %>%
add_text_layer(
source = "bart-stations",
getPosition = ~lng + lat,
# ...
) %>%
add_basemap()
Please note that you use the parameter source
instead of data
.
Layer properties are passed to the add_*_layer
functions either as named list by the properties
argument or as named parameters / keyword arguments via the ...
parameter. The names correspond to the properties of the deck.gl counterparts. Therefore, please see the deck.gl Layer Catalog to determine the available parameters for the used layer. You can also pass a props list and keyword arguments together. Identical properties are overwritten by the latter ones.
Grid Layer example:
// JavaScript code
const layer = new GridLayer({
id: "grid-layer",
data: data,
extruded: true,
cellSize: 200,
elevationScale: 4,
getPosition: d => [d.lng, d.lat]
});
# Corresponding R code
# using named arguments
deck <- deckgl() %>%
add_grid_layer(
id = "grid-layer",
data = data,
extruded = TRUE,
cellSize = 200,
elevationScale = 4,
getPosition = ~lng + lat
)
# ... using a named props list
props <- list(
cellSize = 200,
extruded = TRUE,
# ...
)
deckgl() %>%
add_grid_layer(
data = data,
properties = props
)
According to the style conventions in R, camelCased
parameters in deck.gl can also be passed as snake_cased
parameters in R. For example, getPosition
can be passed to deck.gl as get_position
:
deckgl() %>%
add_grid_layer(
get_position = ~lng + lat,
cell_size = 200,
# ...
)
Use the formula syntax to define data accessors:
props <- list(
getPosition = ~lng + lat # js: d => [d.lng, d.lat]
getFillColor = ~color # js: d => d.color
# ...
)
The example above assumes that your data contains the columns lng
, lat
and color
.
It is also possible to pass JavaScript code by using the JS
function in R:
In deck.gl colors are represented by [r, g, b, a]
arrays. In R you can pass hex color codes or color names to all color props of the add_*_layer
functions. They are automatically converted to the required format:
deckgl() %>%
add_grid_layer(
colorRange = RColorBrewer::brewer.pal(6, "Blues"),
# ...
)
The tooltip for a layer can be set via the tooltip
parameter. You can either pass a single template string or a list with the following properties (see also use_tooltip
):
html
: A template string that will be set as the innerHTML
of the tooltip.style
: A cssText
string that will modefiy the default style of the tooltip.The tooltip string is a so called “mustache” template in which variable names are identified by the double curly brackets that surround them. The variable names available to the template are given by deck.gl’s pickingInfo.object and vary by layer.
Arc Layer example:
data("bart_segments")
props <- list(
getWidth = 12,
getSourcePosition = ~from_lng + from_lat,
getTargetPosition = ~to_lng + to_lat,
getSourceColor = "yellow",
getTargetColor = "orange",
tooltip = use_tooltip(
html = "{{from_name}} to {{to_name}}",
style = "background: steelBlue; border-radius: 5px;"
)
)
deckgl(zoom = 9.5, pitch = 35) %>%
add_arc_layer(data = bart_segments, properties = props) %>%
add_basemap()
See mustache.js for a complete syntax overwiew.
Controls are displayed as overlays on top of the map / deck. Usually you can set the position and the style of the control. The most basic control is a simple text box:
deckgl() %>%
add_basemap() %>%
add_control(
html = "Plain Base Map",
pos = "top-right",
style = "background: steelblue; color: white"
)
You can add an instance of the ace editor in JSON mode to the map by using add_json_editor
:
deckgl() %>%
add_grid_layer(
# ...
) %>%
add_json_editor()
This allows you to change your layer props on the fly. You can toggle the visibility of the editor by pressing “e”.
With add_legend
you can add a custom legend to your widget:
deckgl() %>%
add_basemap() %>%
add_legend(
colors = c("yellow", "orange"),
labels = c("Cake", "Icecream"),
title = "Sweets"
)
In most cases, you will create the legend automatically using a palette function:
data_column <- 1:10
pal <- scales::col_bin("Blues", data_column, bins = 5)
deckgl() %>%
add_basemap() %>%
add_legend_pal(pal, title = "Blues")
By default, add_basemap
adds a carto basemap to the widget.
To use basemaps from mapbox it is recommended that you store your API access token in an environment variable called MAPBOX_API_TOKEN
:
# If not set globally
#Sys.setenv(MAPBOX_API_TOKEN = "xyz")
deckgl() %>%
add_mapbox_basemap("mapbox://styles/mapbox/light-v9")
You can run the API examples from the add_*_layer
functions with example(add_*_layer)
:
example(add_grid_layer)
With the renderDeckgl
and deckglOutput
functions you can use r-deckgl in shiny applications:
library(shiny)
library(deckgl)
backend <- function(input, output) {
output$rdeck <- renderDeckgl({
deckgl() %>%
add_grid_layer(
data = sf_bike_parking,
getPosition = ~lng + lat,
cellSize = 400,
pickable = TRUE
) %>%
add_basemap()
})
}
frontend <- fluidPage(
deckglOutput("rdeck")
)
shinyApp(frontend, backend)
To update a deckgl
instance use deckgl_proxy
in combination with update_deckgl
.
Furthermore, the onclick
event sends deck.gl’s picking info object to your shiny application and updates the corresponding input in the form of input$widget_id_onclick
. For example, if the widget id is rdeck
, you can access the pickingInfo
object with input$rdeck_onclick
:
backend < -function(input, output) {
# ...
observeEvent(input$rdeck_onclick, {
info <- input$rdeck_onclick
print(info$object)
})
}


clustifyr classifies cells and clusters in single-cell RNA sequencing experiments using reference bulk RNA-seq data sets, sorted microarray expression data, single-cell gene signatures, or marker genes.
Single cell transcriptomes are difficult to annotate without extensive knowledge of the underlying biology of the system in question. Even with this knowledge, accurate identification can be challenging due to the lack of detectable expression of common marker genes. ClustifyR solves this problem by automatically annotating single cells or clusters using scRNA-seq, bulk RNA-seq data, microarray or marker gene lists. Additional functions allow for exploratory analysis of similarities between single cell RNA-seq datasets and reference data.
In this example we use the following built-in input data:
pbmc_matrix_small
)pbmc_meta
)pbmc_vargenes
)-pbmc_bulk_matrix
):We then calculate correlation coefficients and plot them on a pre-calculated tSNE projection (stored in pbmc_meta
).
library(clustifyr)
res <- clustify(
input = pbmc_matrix_small,
metadata = pbmc_meta$classified,
ref_mat = pbmc_bulk_matrix,
query_genes = pbmc_vargenes
)
plot_cor(
res,
pbmc_meta,
colnames(res)[1],
cluster_col = "classified"
)
#> [[1]]
Alternatively, clustify
can take a clustered seurat
object (both v2 and v3) and assign identities. New reference matrix can be made directly from seurat
object as well. Other scRNAseq experiment object types are supported as well.
res <- clustify(
input = s_small,
cluster_col = "res.1",
ref_mat = pbmc_bulk_matrix,
seurat_out = T,
dr = "tsne"
)
res2 <- clustify(
input = s_small3,
cluster_col = "RNA_snn_res.1",
ref_mat = pbmc_bulk_matrix,
seurat_out = T,
dr = "tsne"
)
res2
#> An object of class Seurat
#> 230 features across 80 samples within 1 assay
#> Active assay: RNA (230 features)
#> 2 dimensional reductions calculated: pca, tsne
new_ref_matrix <- seurat_ref(
s_small,
cluster_col = "res.1",
var.genes_only = FALSE
)
head(new_ref_matrix)
#> 0 1 2 3
#> MS4A1 4.517255 3.204766 0.000000 0.000000
#> CD79B 4.504191 3.549095 2.580662 0.000000
#> CD79A 4.457349 4.199849 0.000000 0.000000
#> HLA-DRA 6.211779 6.430463 3.659590 4.169965
#> TCL1A 4.394310 2.837922 0.000000 0.000000
#> HLA-DQB1 4.380289 4.325293 0.000000 1.666167
Similarly, clustify_lists
can also handle identity assignment of matrix or seurat
object based on marker gene lists.
res <- clustify_lists(
pbmc_matrix_small,
per_cell = FALSE,
cluster_info = pbmc_meta,
cluster_col = "classified",
marker = pbmc_markers,
marker_inmatrix = FALSE,
metric = "hyper"
)
res <- clustify_lists(
s_small,
per_cell = FALSE,
marker = pbmc_markers,
marker_inmatrix = FALSE,
cluster_col = "res.1",
seurat_out = TRUE,
dr = "tsne"
)
More reference data (including tabula muris, immgen, etc) is available at https://github.com/rnabioco/clustifyrdata.


Digest
public class Digest : Updateable
Public API for message digests.
Usage is straightforward
let s = "The quick brown fox jumps over the lazy dog."
var md5 : Digest = Digest(algorithm:.MD5)
md5.update(s)
let digest = md5.final()
-
The status of the Digest. For CommonCrypto this will always be
.Success
. It is here to provide for engines which can fail.Declaration
Swift
public var status = Status.Success
-
Enumerates available Digest algorithms
See moreDeclaration
Swift
public enum Algorithm
-
Create an algorithm-specific digest calculator - parameter alrgorithm: the desired message digest algorithm
Declaration
Swift
public init(algorithm: Algorithm)
Parameters
alrgorithm
the desired message digest algorithm
-
Low-level update routine. Updates the message digest calculation with the contents of a byte buffer.
Declaration
Swift
public func update(buffer: UnsafePointer<Void>, _ byteCount: size_t) -> Self?
Parameters
buffer
the buffer
the
number of bytes in buffer
Return Value
this Digest object (for optional chaining)
-
Completes the calculate of the messge digest - returns: the message digest
Declaration
Swift
public func final() -> [UInt8]
Return Value
the message digest


The syntax is simple: construct a spacer by passing the original formatter, and the text to space (prepend and append). Use:
%
to mean the original formatter text"%"
is prepended before"%"
is appended afterExamples:
// prefix "[" before index, and append "] " after it. formatter::spacer( formatter::idx(), "[%] "); // prefix "{T" before thread_id, and append "} " after it formatter::spacer( formatter::thread_id(), "{T%} ");
When adding a spacer formatter, you'll do something similar to:
g_l()->writer().add_formatter( formatter::spacer( formatter::idx(), "[%] ") );
However, to make this even simpler, I allow an ever easier syntax:
// equivalent to the above g_l()->writer().add_formatter( formatter::idx(), "[%] " );


> show dbs;
local 0.078125GB
> use drupal;
> show collections;
> db.awesomestuff.insert({"a":1, "b":2});
> db.awesomestuff.find();
{"_id":ObjectId("526965cd93259605e9afbc41"), "a":1, "b":2}
> show collections;
system.indexes
awesomestuff
> show dbs;
drupal 0.203125GB
local 0.078125GB
> db.awesomestuff.insert({
"a": [1, 2, 3], "b":"some string"
});
> db.awesomestuff.insert({
"a": [[1,2,4], [4,5,6], [7,8,9]]
});
> db.awesomestuff.insert({
"a": {
"name" : "Dries",
"interests" : ["Drupal", "MongoDB"]
}
);
| MySQL | MongoDB |
|---|---|
| database | database |
| table | collection |
| row | document |
| column | field |
| index | index |
| joins | embedded documents and linking |
persistent, easy to set-up, fast ("fire and forget"), automatic garbage collection
Photo by http://www.webdesignerdepot.com/2009/03/40-comics-strips-for-web-designers/easy to set-up, fast ("fire and forget"), very good for multi-server envs, uses capped collections
Photo by Which? Campaigns - http://www.flickr.com/photos/71528417@N02/6709386951easy to set-up, per-queue-collection
Photo by Darren Tunnicliff - http://www.flickr.com/photos/25572591@N07/3717976312a bit funky :), stores blocks configuration, exposes UI
Photo by capitaine_commerce - http://www.flickr.com/photos/8488292@N04/1807465667stores entites /w fields as Mongo docs, still needs base entity table, lazy destruction of stale data, new fields added very easily
Photo by Aleksej Leonov - http://www.flickr.com/photos/31849470@N02/7652495954
{
"_id" : 60549286,
"_type" : "node",
"_bundle" : "story",
"_revision_id" : 150412786,
"nid" : 60549286,
"vid" : 150412786,
"type" : "story",
"language" : "und",
"title" : "Hello world!",
"uid" : 2044271,
"status" : 1,
"created" :<PHONE_NUMBER>,
"changed" :<PHONE_NUMBER>,
"comment" : 2,
"promote" : 1,
"sticky" : 0,
"field_image" : {
"fid" : 47928616,
"width" : 594,
"height" : 396,
"alt" : "",
"title" : ""
},
"body" : {
"value" : "MongoDB is great!
"
},
"field_tags" : [
{ "tid" : 14244596 },
{ "tid" : 14244596 }
]
}
www.google-melange.com/gci/homepage/google/gci2013 | @slurpee on #drupal-gci


Back in October 2015 I wrote this post about cleaning up some data in one of our databases. he problem was essentially two-fold. Remove duplicates and then retain items that were not found in a validation list.
I’m writing this as a first new post on this the newest incantation of my blog as a way of charting how far I’ve come in 18 or so months.
Here’s How I did the original version:
Twelve lines of code (plus comments). I was pretty chuffed with that back then!
Here’s how I’d write it now:
So that’s a 50% shorter script. Back then I had no idea what a set was, or heard of list comprehension. Oh, and I’m a bit more PEP8 compliant these days!
It’s funny reading a lot of my old code now. My current code is far from amazing, but it’s certainly better than it was.
The moral of this story - keep going, you will improve!


{% extends "base_template.html" %} {% autoescape None %} {% block content %}
Here are some helpful links for learning web development.


Class: Nanook::Node
Overview
The Nanook::Node
class contains methods to manage your nano node and query its data of the nano network.
Your node is constantly syncing data with other nodes on the network. When your node first starts up after being built, its database will be empty and it will begin synchronizing and downloading data of the nano ledger to its local database. The ledger is the central record of all accounts and transactions. Some of the methods in this class query your node's database formed from the nano ledger, and so the responses are determined by the completeness of your node's database.
You can determine how synchronized your node is with the nano ledger with the #sync_progress method.
Initializing
Initialize this class through the convenient #node method:
node = Nanook.new.node
Or compose the longhand way like this:
rpc_conn = Nanook::Rpc.new
node = Nanook::Node.new(rpc_conn)
Constant Summary
Constants included from Util
Instance Method Summary collapse
-
#account_count ⇒ Integer
(also: #frontier_count)
The number of accounts in the nano ledger–essentially all accounts with open blocks.
-
#block_count ⇒ Hash{Symbol=>Integer}
The count of all blocks downloaded to the node, and blocks still to be synchronized by the node.
-
#bootstrap(address:, port:) ⇒ Boolean
Initialize bootstrap to a specific IP address and port.
-
#bootstrap_any ⇒ Boolean
Initialize multi-connection bootstrap to random peers.
-
#bootstrap_lazy(hash, force: false) ⇒ Boolean
Initialize lazy bootstrap with given block hash.
-
#change_receive_minimum(minimum, unit: Nanook.default_unit) ⇒ Boolean
Sets the receive minimum for wallets on the node.
-
#confirmation_quorum(unit: Nanook.default_unit) ⇒ Hash{Symbol=>String|Integer}
Returns information about node elections settings and observed network state:.
-
#difficulty(include_trend: false) ⇒ Hash{Symbol=>String|Float|Array}
Returns the difficulty values (16 hexadecimal digits string, 64 bit) for the minimum required on the network (network_minimum) as well as the current active difficulty seen on the network (network_current, 5 minute trended average of adjusted difficulty seen on confirmed transactions) which can be used to perform rework for better prioritization of transaction processing.
-
#initialize(rpc) ⇒ Node
constructor
A new instance of Node.
-
#keepalive(address:, port:) ⇒ Boolean
Tells the node to send a keepalive packet to a specific IP address and port.
-
#peers ⇒ Hash{Symbol=>Hash{Symbol=>Integer|String}}
Returns peers information.
-
#receive_minimum(unit: Nanook.default_unit) ⇒ Integer|Float
Returns receive minimum for wallets on the node.
-
#representatives(unit: Nanook.default_unit) ⇒ Hash{Nanook::Account=>Float|Integer}
All representatives and their voting weight.
-
#representatives_online ⇒ Nanook::Account
All online representatives that have voted recently and their weight.
-
#search_pending ⇒ Boolean
Tells the node to look for any account in all available wallets.
-
#stop ⇒ Boolean
Safely shuts down the node.
-
#sync_progress ⇒ Float
The percentage completeness of the synchronization process for your node as it downloads the nano ledger.
-
#synchronizing_blocks(limit: 1000, unit: Nanook.default_unit) ⇒ Hash{Symbol=>String}
(also: #unchecked)
Information about the synchronizing blocks for this node.
- #to_s ⇒ String (also: #inspect)
-
#uptime ⇒ Integer
Returns node uptime in seconds.
-
#version ⇒ Hash{Symbol=>Integer|String}
(also: #info)
Version information for this node.
Constructor Details
#initialize(rpc) ⇒ Node
Returns a new instance of Node.
33 34 35 |
# File 'lib/nanook/node.rb', line 33 def initialize(rpc) @rpc = rpc end |
Instance Method Details
#account_count ⇒ Integer Also known as: frontier_count
The number of accounts in the nano ledger–essentially all accounts with open blocks. An open block is the type of block written to the nano ledger when an account receives its first payment (see WalletAccount#receive). All accounts that respond true
to Account#exists? have open blocks in the ledger.
44 45 46 |
# File 'lib/nanook/node.rb', line 44 def account_count rpc(:frontier_count, _access: :count) end |
#block_count ⇒ Hash{Symbol=>Integer}
The count of all blocks downloaded to the node, and blocks still to be synchronized by the node.
Example:
{
count: 100,
unchecked: 10,
cemented: 25
}
62 63 64 |
# File 'lib/nanook/node.rb', line 62 def block_count rpc(:block_count, _coerce: Hash) end |
#bootstrap(address:, port:) ⇒ Boolean
Initialize bootstrap to a specific IP address and port.
76 77 78 |
# File 'lib/nanook/node.rb', line 76 def bootstrap(address:, port:) rpc(:bootstrap, address: address, port: port).key?(:success) end |
#bootstrap_any ⇒ Boolean
Initialize multi-connection bootstrap to random peers
83 84 85 |
# File 'lib/nanook/node.rb', line 83 def bootstrap_any rpc(:bootstrap_any).key?(:success) end |
#bootstrap_lazy(hash, force: false) ⇒ Boolean
Initialize lazy bootstrap with given block hash
93 94 95 |
# File 'lib/nanook/node.rb', line 93 def bootstrap_lazy(hash, force: false) rpc(:bootstrap_lazy, hash: hash, force: force, _access: :started) == 1 end |
#change_receive_minimum(minimum, unit: Nanook.default_unit) ⇒ Boolean
Sets the receive minimum for wallets on the node. The value is in Nano
by default. To specify an amount in raw
, pass the argument unit: :raw.
Example:
account.change_receive_minimum(0.01) # true
329 330 331 332 333 334 335 |
# File 'lib/nanook/node.rb', line 329 def change_receive_minimum(minimum, unit: Nanook.default_unit) validate_unit!(unit) minimum = NANO_to_raw(minimum) if unit == :nano rpc(:receive_minimum_set, amount: minimum).key?(:success) end |
#confirmation_quorum(unit: Nanook.default_unit) ⇒ Hash{Symbol=>String|Integer}
Returns information about node elections settings and observed network state:
-
`quorum_delta`: delta tally required to rollback block
-
`online_weight_quorum_percent`: percentage of online weight for delta
-
`online_weight_minimum`: minimum online weight to confirm block
-
`online_stake_total`: currently observed online total weight
-
`peers_stake_total`: known peers total weight
-
`peers_stake_required`: effective stake needed from directly connected peers for quorum
Example:
node.confirmation_quorum
Example response:
{
"quorum_delta": 43216377.43025059,
"online_weight_quorum_percent": 50,
"online_weight_minimum": 60000000.0",
"online_stake_total": 86432754.86050119,
"peers_stake_total": 84672338.52479072,
"peers_stake_required": 60000000.0"
}
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 |
# File 'lib/nanook/node.rb', line 123 def confirmation_quorum(unit: Nanook.default_unit) validate_unit!(unit) response = rpc(:confirmation_quorum, _coerce: Hash) return response unless unit == :nano response[:quorum_delta] = raw_to_NANO(response[:quorum_delta]) response[:online_weight_minimum] = raw_to_NANO(response[:online_weight_minimum]) response[:online_stake_total] = raw_to_NANO(response[:online_stake_total]) response[:peers_stake_total] = raw_to_NANO(response[:peers_stake_total]) response[:peers_stake_required] = raw_to_NANO(response[:peers_stake_required]) response.compact end |
#difficulty(include_trend: false) ⇒ Hash{Symbol=>String|Float|Array}
Returns the difficulty values (16 hexadecimal digits string, 64 bit) for the minimum required on the network (network_minimum) as well as the current active difficulty seen on the network (network_current, 5 minute trended average of adjusted difficulty seen on confirmed transactions) which can be used to perform rework for better prioritization of transaction processing. A multiplier of the network_current from the base difficulty of network_minimum is also provided for comparison.
Example:
node.difficulty(include_trend: true)
Example response:
{
network_minimum: "ffffffc000000000",
network_current: "ffffffc1816766f2",
multiplier: 1.024089858417128,
difficulty_trend: [
1.156096135149775,
1.190133894573061,
1.135567138563921,
1.000000000000000,
]
}
171 172 173 174 175 176 177 |
# File 'lib/nanook/node.rb', line 171 def difficulty(include_trend: false) rpc(:active_difficulty, include_trend: include_trend, _coerce: Hash).tap do |response| response[:multiplier] = response[:multiplier].to_f response[:difficulty_trend].map!(&:to_f) if response.key?(:difficulty_trend) end end |
#keepalive(address:, port:) ⇒ Boolean
Tells the node to send a keepalive packet to a specific IP address and port.
69 70 71 |
# File 'lib/nanook/node.rb', line 69 def keepalive(address:, port:) rpc(:keepalive, address: address, port: port).key?(:started) end |
#peers ⇒ Hash{Symbol=>Hash{Symbol=>Integer|String}}
Returns peers information.
Example response:
{
:"[::ffff:<IP_ADDRESS>]:7075" => {
protocol_version: 20,
node_id: "node_1y7j5rdqhg99uyab1145gu3yur1ax35a3b6qr417yt8cd6n86uiw3d4whty3",
type: "udp"
},
:"[::ffff:<IP_ADDRESS>]:7075" => { ... }
}
199 200 201 |
# File 'lib/nanook/node.rb', line 199 def peers rpc(:peers, peer_details: true, _access: :peers, _coerce: Hash) end |
#receive_minimum(unit: Nanook.default_unit) ⇒ Integer|Float
Returns receive minimum for wallets on the node.
Example:
account.receive_minimum # => 0.01
346 347 348 349 350 351 352 353 354 |
# File 'lib/nanook/node.rb', line 346 def receive_minimum(unit: Nanook.default_unit) validate_unit!(unit) amount = rpc(:receive_minimum, _access: :amount) return amount unless unit == :nano raw_to_NANO(amount) end |
#representatives(unit: Nanook.default_unit) ⇒ Hash{Nanook::Account=>Float|Integer}
All representatives and their voting weight.
Example:
node.representatives
Example response:
{
Nanook::Account:<PHONE_NUMBER>060170000000000000000000000,
Nanook::Account:<PHONE_NUMBER>9999999999999999000000,
Nanook::Account: 0
}
219 220 221 222 223 224 225 226 227 228 229 230 231 |
# File 'lib/nanook/node.rb', line 219 def representatives(unit: Nanook.default_unit) validate_unit!(unit) response = rpc(:representatives, _access: :representatives, _coerce: Hash) r = response.map do |account_id, weight| weight = raw_to_NANO(weight) if unit == :nano [as_account(account_id), weight] end Hash[r] end |
#representatives_online ⇒ Nanook::Account
All online representatives that have voted recently and their weight.
Example:
node.representatives_online # => [Nanook::Account, ...]
240 241 242 243 244 |
# File 'lib/nanook/node.rb', line 240 def representatives_online rpc(:representatives_online, _access: :representatives, _coerce: Array).map do |representative| as_account(representative) end end |
#search_pending ⇒ Boolean
Tells the node to look for any account in all available wallets.
Example:
node.search_pending #=> true
252 253 254 |
# File 'lib/nanook/node.rb', line 252 def search_pending rpc(:search_pending_all).key?(:success) end |
#stop ⇒ Boolean
Safely shuts down the node.
259 260 261 |
# File 'lib/nanook/node.rb', line 259 def stop rpc(:stop).key?(:success) end |
#sync_progress ⇒ Float
The percentage completeness of the synchronization process for your node as it downloads the nano ledger. Note, it's normal for your progress to not ever reach 100. The closer to 100, the more complete your node's data is, and so the query methods in this class become more reliable.
301 302 303 304 305 306 307 308 309 |
# File 'lib/nanook/node.rb', line 301 def sync_progress response = rpc(:block_count, _coerce: Hash) count = response[:count] unchecked = response[:unchecked] total = count + unchecked count.to_f * 100 / total.to_f end |
#synchronizing_blocks(limit: 1000, unit: Nanook.default_unit) ⇒ Hash{Symbol=>String} Also known as: unchecked
Returns information about the synchronizing blocks for this node.
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 |
# File 'lib/nanook/node.rb', line 268 def synchronizing_blocks(limit: 1000, unit: Nanook.default_unit) validate_unit!(unit) params = { count: limit, json_block: true, _access: :blocks, _coerce: Hash } response = rpc(:unchecked, params).map do |block, info| info[:account] = as_account(info[:account]) if info[:account] info[:link_as_account] = as_account(info[:link_as_account]) if info[:link_as_account] info[:representative] = as_account(info[:representative]) if info[:representative] info[:previous] = as_block(info[:previous]) if info[:previous] info[:link] = as_block(info[:link]) if info[:link] info[:balance] = raw_to_NANO(info[:balance]) if unit == :nano && info[:balance] [as_block(block), info] end Hash[response] end |
#to_s ⇒ String Also known as: inspect
180 181 182 |
# File 'lib/nanook/node.rb', line 180 def to_s self.class.name end |
#uptime ⇒ Integer
Returns node uptime in seconds
314 315 316 |
# File 'lib/nanook/node.rb', line 314 def uptime rpc(:uptime, _access: :seconds, _coerce: Hash) end |
#version ⇒ Hash{Symbol=>Integer|String} Also known as: info
Returns version information for this node.
357 358 359 |
# File 'lib/nanook/node.rb', line 357 def version rpc(:version, _coerce: Hash) end |


Class: Aws::IoT::Types::CodeSigning
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-iot/lib/aws-sdk-iot/types.rb |
Overview
Describes the method to use when code signing a file.
Constant Summary
Instance Attribute Summary
-
#aws_signer_job_id ⇒ String
rw
The ID of the
AWSSignerJob
which was created to sign the file. -
#custom_code_signing ⇒ Types::CustomCodeSigning
rw
A custom method for code signing a file.
-
#start_signing_job_parameter ⇒ Types::StartSigningJobParameter
rw
Describes the code-signing job.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#aws_signer_job_id ⇒ String
(rw)
The ID of the AWSSignerJob
which was created to sign the file.
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/types.rb', line 2045
class CodeSigning < Struct.new( :aws_signer_job_id, :start_signing_job_parameter, :custom_code_signing) SENSITIVE = [] include Aws::Structure end
#custom_code_signing ⇒ Types::CustomCodeSigning (rw)
A custom method for code signing a file.
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/types.rb', line 2045
class CodeSigning < Struct.new( :aws_signer_job_id, :start_signing_job_parameter, :custom_code_signing) SENSITIVE = [] include Aws::Structure end
#start_signing_job_parameter ⇒ Types::StartSigningJobParameter (rw)
Describes the code-signing job.
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/types.rb', line 2045
class CodeSigning < Struct.new( :aws_signer_job_id, :start_signing_job_parameter, :custom_code_signing) SENSITIVE = [] include Aws::Structure end


This is just a quick email to let you know we have successfully reset your password at {{app_name}}. Please login and change this immediately!
{{password}}
login and change it


Regulation of B-cell development by BCAP and CD19 through their binding to phosphoinositide 3-kinase.
Despite the importance of phosphoinositide 3-kinase (PI3K) in B-cell development, its activation mechanism still remains elusive. In this study, we show that deletion of both BCAP and CD19 leads to an almost complete block of BCR-mediated Akt activation and to severe defects in generation of immature and mature B cells. The YXXM motifs in BCAP and CD19 are crucial for regulating B-cell development in that mutation of these motifs abrogated their ability to induce BCR-mediated Akt activation as well as to promote B-cell development. Furthermore, the developmental defect in CD19(-/-)BCAP(-/-) B cells was partly relieved by introducing a constitutively active form of PI3K or PDK1. Together, our data suggest that BCAP and CD19 have complementary roles in BCR-mediated PI3K activation, thereby, at least in part, contributing to B-cell development.


Trust Real-Estate Houses for Rent. Find a house to rent anywhere, of any type, on any price
Trust Real-Estate
COUNTRY: United Kingdom
REGION: Greater London NW3
CITY: London
TYPE: 2floor maisonette with garden
AREA: 230 sqm
PRICE: 3000£ / month
TEL |
TRANSPORTATION: YES |
WEBSITE: RENTAHOME |
CLIENTS ENROLLED: 870|
CLIENTS SUPPORT: YES
Among Love all the beautiful garden ideas for my yard. See more ideas about Outdoor gardens Love all the beautiful garden ideas for my yard. See more ideas about Outdoor gardens Love all the beautiful garden ideas for my yard. See more ideas about Outdoor gardens Love all the beautiful garden ideas for my yard. See more ideas about Outdoor gardens
MAP DIRECTIONS:


3D Three Line Break Chart
2D Renko Chart
2D Kagi Chart
2D Point and Figure Chart
2D Three Line Break Chart


First lady Melania Trump accepts delivery of White House Christmas tree
by Daniel UriaNov. 25 (UPI) -- First lady Melania Trump accepted the White House Christmas tree outside of the presidential residence on Monday.
The 18.5-foot douglas fir tree from Mahantongo Valley Farms in Pitman, Penn., was delivered to the White House on a horsedrawn carriage at around noon on Monday.
Trump inspected the tree as the U.S. Marine Band played "O Christmas Tree."
The first lady also posed for photos with Mahantongo Valley Farms owner Larry Snyder and his family.
Snyder was named Grand Champion of the annual tree contest held by the National Christmas Tree Association, which selects the White House Tree each year.
"We are honored to have the opportunity to represent the tree growers of America, by continuing the tradition of providing a tree to the White House Blue Room, which will be viewed by millions of people," said Snyder. "This will be a memorable experience of a lifetime for our family, especially for our children and grandchildren, who are accompanying us for the presentation fo the tree to the White House."


A blockchain is a growing list of records, called blocks, which are linked using cryptography. Each block contains a cryptographic hash of the previous block, a timestamp, and transaction data (generally represented as a merkle tree root hash). Blockchain was invented by a person using the name Satoshi Nakamoto in 2008 to serve as the public transaction ledger of the cryptocurrency bitcoin. The identity of Satoshi Nakamoto is unknown. The invention of the blockchain for bitcoin made it the first digital currency to solve the double-spending problem without the need of a trusted authority or central server. The bitcoin design has inspired other applications, and blockchains which are readable by the public are widely used by cryptocurrencies. Blockchain is considered a type of payment rail. Private blockchains have been proposed for business use. Sources such as Computerworld called the marketing of such blockchains without a proper security model "snake oil".
Blockchain technology can be integrated into multiple areas. The primary use of blockchains today is as a distributed ledger for cryptocurrencies, most notably bitcoin. There are a few operational products maturing from proof of concept by late 2016. As of 2016, some observers remain skeptical. Steve Wilson, of Constellation Research, believes the technology has been hyped with unrealistic claims. To mitigate risk, businesses are reluctant to place blockchain at the core of the business structure.
Some examples of use include:
A public blockchain has absolutely no access restrictions. Anyone with an internet connection can send transactions to it as well as become a validator (i.e., participate in the execution of a consensus protocol). Usually, such networks offer economic incentives for those who secure them and utilize some type of a Proof of Stake or Proof of Work algorithm. Some of the largest, most known public blockchains are Bitcoin and Ethereum.
A private blockchain is permissioned. One cannot join it unless invited by the network administrators. Participant and validator access is restricted. This type of blockchains can be considered a middle-ground for companies that are interested in the blockchain technology in general but are not comfortable with a level of control offered by public networks. Typically, they seek to incorporate blockchain into their accounting and record-keeping procedures without sacrificing autonomy and running the risk of exposing sensitive data to the public internet.
A consortium blockchain is often said to be semi-decentralized. It, too, is permissioned but instead of a single organization controlling it, a number of companies might each operate a node on such a network. The administrators of a consortium chain restrict users' reading rights as they see fit and only allow a limited set of trusted nodes to execute a consensus protocol.
Back to HomePage


Recipes
Food Channel
How to cook the Perfect Steak?
How to cook the Perfect Burger?
How to cook.....
Pricing of Ingredients
Sign In
×
Search youtube for some Inspiraton!
2
4
6
8
10