User Stories:
- I can pass a string as a parameter, and it will check to see whether that string contains either a unix timestamp or a natural language date (example: January 1, 2016)
- If it does, it returns both the Unix timestamp and the natural language form of that date.
- If it does not contain a date or Unix timestamp, it returns
null
for those properties.
https://dry-reef-56215.herokuapp.com/December%2015,%202015
https://dry-reef-56215.herokuapp.com/1450137600
{ "unix":<PHONE_NUMBER>, "natural": "December 15, 2015" }
{ "unix": null, "natural": null }


?6
7
8
9
10
'
.
XT
v
The
New
York
copyright
reserved
botanical
Garden
New
York
Botanical
Garden
"""
lblt312
REVISION
OF
CANAVALIA,
1962
Subgenus
Canavalia
C.
ensiformis
(L.)
DC.—det.
J.
Sauer
[P.
Duss
no.
1077,
"pais
sabre,"
cultive^
et
a
l'etat
sauvage,
St.
Pierre,
Martinique,
1882]
1616312
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


The Institute is an economic research and applied research and consulting group that provides customized client solutions and strategies to facilitate decision making and planning that enhances growth, impact, and sustainability for organizations.
The Institute for Public Policy & Economic Development (The Institute) was formed as a partnership of 12 colleges and universities in the Scranton/ Wilkes-Barre/ Hazleton Metropolitan Statistical Area and the business community. The Institute’s managing partner is Wilkes University.
Formed in 2004, the center began operations with pledged capital from business and industry, higher education, and nonprofit organizations to provide community based research in northeastern Pennsylvania to provide data for leaders and organizations to make informed decisions for revitalization and economic sustainability. From there, The Institute emerged as a premier entity with capacity for both community based research and proprietary research for public, private, and non-profit sectors to use in developing feasibility, strategy, programs, initiatives, and policy.


By submitting this form, you agree to receive calls at any time, including hours outside of business hours. This is so that we may reach you as soon as possible in order to consult on your potential case.


Skills Safari for WordPress by Kevin Weber
Work in progress, or at least I do not guarantee anything.
Instructions
- Upload the plugin to your site.
- Move the file ‘data.json’ to whereever you want.
- Edit ‘data.json’.
- Paste the exemplery code into your WordPress template and setup the path to your ‘data.json’ file in the ‘data-source’ attribute.
- Activate the plugin.
Exemplery code
```
<?php if ( function_exists( ‘kevinw_sf’ ) ) { ?>
Skills Safari by Kevin Weber
<?php } ?>
```


Jun 20, 2014 3:42 PM
Join Gary Natriello and Hui Soo Chae for a course that explores the social dimensions of evaluation in contemporary society. Individuals in modern societies live in a world in which evaluation is ubiquitous. More and more aspects of our performances are subject to informal and/or formal assessment. Everything from our health as infants, to our performance in schools as youngsters, our potential to benefit from higher education, and our capacity to contribute in the workplace is evaluated. This course examines the social dimensions of the development and operation of different kinds of evaluation systems in modern societies. The course is divided into five sections. Major topics include the social, political, and intellectual contexts for evaluation, the institutional bases of evaluation activities, the social settings in which evaluation takes place, and the effects of evaluations on individuals and groups.


Since the system subroutines are used by other library routines that
require reentrancy, libc.a provides cover routines (for example,
the reentrant version of fork
is _fork_r
). These cover
routines are consistent with the other reentrant subroutines in this
library, and achieve reentrancy by using a reserved global data block
(see Reentrancy).


Building ezEngine
To try out ezEngine, you can download a precompiled binary package. This article describes how you can build the engine yourself, which enables you to extend the engine with custom functionality.
Getting the Code and Data
- Clone a branch from the GitHub repository.
- If you need a good git GUI, have a look at Fork.
- Check out the 'dev' branch.
- Unless your git client already checks out git sub-modules for you, also run
git submodule init
andgit submodule update
in your local clone. The EZ project uses submodules to deliver additional data such as sample content and precompiled tools.
Platform Builds
Build Types
EZ sets up three build configuration types:
- Debug
- Dev
- Shipping
While developing your game you should either use a Debug or a Dev build.
The Debug build is best when you want to use a C++ debugger to investigate problems. It includes the necessary debug symbols and has many optimizations disabled, which makes it much easier to step through the code. Debug builds are significantly slower than the other build types.
The Dev build has most of the optimizations enabled, yet still includes debug symbols. The Dev build is 3x to 10x faster than a Debug build in most cases and is very close to the speed of a Shipping build. Stepping through the C++ code with a debugger is possible, though it often behaves erratic due to the optimizations (inlining and such). For most developers the Dev build should be the main configuration to use.
The Shipping build has all optimizations enabled. It does not include debug symbols anymore and it also has all the developer features disabled. That means things like ezInspector won't work here. Similarly, features like allocation tracking (for detecting memory leaks) and profiling features are disabled as well.


add bill´s total
calculate
settings
evaluate service:
set minimum percentage
set maximum percentage
SET HOW TO ROUND BILL
UP:
DOWN:
save


11.13. Release 0.199
General Changes
- Allow users to create views for their own use when they do not have permission
to grant others access to the underlying tables or views. To enable this,
creation permission is now only checked at query time, not at creation time,
and the query time check is skipped if the user is the owner of the view.
- Add support for spatial left join.
- Add
hmac_md5()
, hmac_sha1()
, hmac_sha256()
, and hmac_sha512()
functions.
- Add
array_sort()
function that takes a lambda as a comparator.
- Add
line_locate_point()
geospatial function.
- Add support for
ORDER BY
clause in aggregations for queries that use grouping sets.
- Add support for yielding when unspilling an aggregation.
- Expand grouped execution support to
GROUP BY
and UNION ALL
, making it possible
to execute aggregations with less peak memory usage.
- Change the signature of
round(x, d)
and truncate(x, d)
functions so that
d
is of type INTEGER
. Previously, d
could be of type BIGINT
.
This behavior can be restored with the deprecated.legacy-round-n-bigint
config option
or the legacy_round_n_bigint
session property.
- Accessing anonymous row fields via
.field0
, .field1
, etc., is no longer allowed.
This behavior can be restored with the deprecated.legacy-row-field-ordinal-access
config option or the legacy_row_field_ordinal_access
session property.
- Optimize the
ST_Intersection()
function for rectangles aligned with coordinate axes
(e.g., polygons produced by the ST_Envelope()
and bing_tile_polygon()
functions).
- Finish joins early when possible if one side has no rows. This happens for
either side of an inner join, for the left side of a left join, and for the
right side of a right join.
- Improve predicate evaluation performance during predicate pushdown in planning.
- Improve the performance of queries that use
LIKE
predicates on the columns of information_schema
tables.
- Improve the performance of map-to-map cast.
- Improve the performance of
ST_Touches()
, ST_Within()
, ST_Overlaps()
, ST_Disjoint()
,
and ST_Crosses()
functions.
- Improve the serialization performance of geometry values.
- Improve the performance of functions that return maps.
- Improve the performance of joins and aggregations that include map columns.
Server RPM Changes
- Add support for installing on machines with OpenJDK.
Security Changes
- Add support for authentication with JWT access token.
JDBC Driver Changes
- Make driver compatible with Java 9+. It previously failed with
IncompatibleClassChangeError
.
Hive Changes
- Fix ORC writer failure when writing
NULL
values into columns of type ROW
, MAP
, or ARRAY
.
- Fix ORC writers incorrectly writing non-null values as
NULL
for all types.
- Support reading Hive partitions that have a different bucket count than the table,
as long as the ratio is a power of two (
1:2^n
or 2^n:1
).
- Add support for the
skip.header.line.count
table property.
- Prevent reading from tables with the
skip.footer.line.count
table property.
- Partitioned tables now have a hidden system table that contains the partition values.
A table named
example
will have a partitions table named example$partitions
.
This provides the same functionality and data as SHOW PARTITIONS
.
- Partition name listings, both via the
$partitions
table and using
SHOW PARTITIONS
, are no longer subject to the limit defined by the
hive.max-partitions-per-scan
config option.
- Allow marking partitions as offline via the
presto_offline
partition property.
Thrift Connector Changes
- Most of the config property names are different due to replacing the
underlying Thrift client implementation. Please see Thrift Connector
for details on the new properties.
SPI Changes
- Allow connectors to provide system tables dynamically.
- Add
resourceGroupId
and queryType
fields to SessionConfigurationContext
.
- Simplify the constructor of
RowBlock
.
Block.writePositionTo()
now closes the current entry.
- Replace the
writeObject()
method in BlockBuilder
with appendStructure()
.


We are driven by a single goal; to ensure all students receive a quality education. We strive to educate and instill a passion for service learning in each and everyone of our members. We aim to help students understand the importance of education through social entrepreneurship and community service.
Started in 2017, PEAC as an organization finds its strength in the service passions of our chapters. Originally rooted in Houston, PEAC has grown its outreach to 8 campus chapters that work to improve the quality of education for students in 3 cities in Texas.
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean.
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts.
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean.
Hold a general body meeting.
Reach out to us so we can assist you.
Assemble an officer team (minimum: 3) and a possible sponsor (teacher or faculty).
Recruit members throughout your school.
Hold a general body meeting.
Vaishnav is a co-founder of the Klein High School Chapter and served on the University of Houston's Executive Board. He is currently studying Finance at the University of Houston.
Vishaal started PEAC in June 2017, with the intention of expanding the idea of service and mentorship to all colleges in Texas. Vishaal holds a bachelor degree in Honors Mathematical Biology and Economics from the University of Houston. Vishaal is also the director/chair of the Mayor's Higher Education Council for the City of Houston.
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics.
“Insert text about how beneficial the program was.”
“Insert text about how beneficial the program was.”
“Insert text about how beneficial the program was.”


| Item Slot | Arcane | Fire | Frost |
| Head | ??? | ??? | ??? |
| Neck | [Eternal Woven Ivy Necklace] | [Eternal Woven Ivy Necklace] | [Eternal Amulet of the Redeemed] |
| Shoulder | [Exquisite Sunderseer Mantle] | [Exquisite Sunderseer Mantle] | [Exquisite Sunderseer Mantle] |
| Back | [Sporecaller's Shroud] | [Sporecaller's Shroud] | [Sporecaller's Shroud] |
| Chest | [Tattered Dreadmist Robe] | [Tattered Dreadmist Robe] | [Tattered Dreadmist Robe] |
| Wrist | [Auxiliary's Cuffs] | [Auxiliary's Cuffs] | [Auxiliary's Cuffs] |
| Hands | [Gloves of Staunched Wounds] | [Gloves of Staunched Wounds] | [Gloves of Staunched Wounds] |
| Waist | [Sailcloth Waistband] | [Sailcloth Waistband] | [Sailcloth Waistband] |
| Legs | [Chum-Coated Leggings] | [Chum-Coated Leggings] | [Chum-Coated Leggings] |
| Feet | [Deranged Alchemist's Slippers] | [Deranged Alchemist's Slippers] | [Deranged Alchemist's Slippers] |
| Ring 1 | [Recruit's Band] | [Recruit's Band] | [Recruit's Band] |
| Ring 2 | [Seal of the Regal Loa] Socketed with +3 Intellect
| [Seal of the Regal Loa] Socketed with +3 Intellect
| [Seal of the Regal Loa] Socketed with +3 Intellect
|
| Trinket 1 | [Conch of Dark Whispers] | [Conch of Dark Whispers] | [Conch of Dark Whispers] |
| Trinket 2 | [Vessel of Skittering Shadows] | [Vessel of Skittering Shadows] | [Vessel of Skittering Shadows] |
| Main Hand | [Recruit's Battle Staff] | [Recruit's Battle Staff] | [Recruit's Battle Staff] |
| Off Hand |


---
layout: game-page
redirect_from: /game/eternal-storm
title: Eternal Storm
year: 2006
semester: Spring
description: "Isometric space-age bombing game.
Taking place in 3305 A.D, Eternal Storm dives into the rich clouds of Jupiter, where the Juno Corporation uses automated mining platforms to maintain a monopoly on the collection of Hydrogen-3 fuel.
Inside the Great Red Spot of Jupiter, a monstrous storm three times the size of Earth, Juno is rumored to have found the storm's source.
Hidden by the fury of this storm, a few brave pilots launch a rebellion -- the Jupiter Liberation Front -- seeking to strike Juno in its heart to uncover the source of its secrets."
tags: Windows Singleplayer
# tag options: "Windows", "Mac", "Linux",
# "Singleplayer", "Multiplayer",
# "Controller-Compatible", "VR",
# "Game-Jam"
project_members: {
Chris DeLeon: "Producer, Programming, Game Design, Cutscene Art, Manual/Interface Design, Voice Acting",
Chris Strickland: Playtesting,
Colin Newby: Playtesting,
Danny Traylor: Sound Design,
Eric Barndollar: Music,
Eric Foote: Level Design,
George Shannon: Writing,
Greg Newby: "Playtesting Lead, Voice Acting, Game Design",
Jared Luxenberg: Web Design,
Jennifer Smith: Playtesting,
Joe Kincaid: Sound Design,
Joe Pfeil: Sound Design Lead,
John Nesky: 3D Art,
Joseph Chakola: Sound Design,
Josh Schnarr: "3D Art Lead, Voice Acting",
Kenneth Chan: Level Design,
Matt Kent: "Music, Sound Design",
Megan Sasser: Sound Design,
Ning Sung Lee: Cursor Art,
Robert Strickland: "Level Design, 3D Art, Voice Acting",
Susan Smith: Playtesting
}
stage_game_path: eternal-storm/
builds: {
Windows: eternal-storm.win32.setup.exe
}
thumbnail: eternal-storm-1.jpg
top-img: eternal-storm-1.jpg
screenshots: [
eternal-storm-1.jpg,
eternal-storm-2.jpg
]
# Optional
top-img-fit: cover
# top-img-fit options:
# "cover" - Cover the entire top area with the image, without squashing/stretching
# "fill" - Fit the FULL image into the top area, squashing/stretching as necessary
---


This
Executor shows a graphic view of the
contents
of an LTR candidate, found by
LTRID and
defined
in a RetroVID script. It is in a state of development.
There is one parameter:
- InputFile: The name of the file with LTR candidate
descriptions. Default: RetroVID_001Script.txt.
When run, LTRview shows a menu with the LTR candidates available, and
one of them, usually the first, is displayed in a window.
The window consists of a number of narrow horizontal strips showing
various kinds of information, each with a name to the left. There are
also buttons to save the display as a (rather unwieldy) PNG, EPS or
JPEG
file.
The horizontal axis is defined by the 'Sequence' strip, which shows all
the bases in the LTR, plus ten leading and ten trailing. Position
numbers
are shown at intervals. Vertical black lines (going through the entire
diagram)
mark the beginning, hotspot (T in AATAAA or equivalent) and end of the
LTR. Vertical blue lines mark the suggested start and end of the R part
of the LTR.
The other strips are at present (see
LTRID
for some clarification), with the ones related to internal analysis of
the LTR above and those related to LTR identification below the
'Sequence' strip:
- MEME50: The score of the MEME50 weight matrix
(between min and max values). Maxima are marked with a vertical red
line.
- TATAA: The score of the TATAAA box weight matrix
(between min and max values). Maxima are marked with a vertical red
line.
- RU5 neural net: The score (between 0 and 1) of the
neural network defined by the file RU5120NN.txt. Maxima are marked with
a vertical red line.
- Inrsites: Occurrences of any of the motifs defined in
Inrvariants.txt in
Database.
- U3R neural net: The score (between 0 and 1) of the
neural network defined by the file U3R120NN.txt. Maxima are marked with
a vertical red line. Values are associated with the position at the end
of the net.
- REndModifier: The value of REndModifier.
- U5 neural net: The score (between 0 and 1) of the
neural network defined by the file U5NN.txt. Maxima are marked with a
vertical
red line.
- U3 neural net: The score (between 0 and 1) of the
neural network defined by the file U3NN.txt. Maxima are marked with a
vertical
red line.
- Transcr. sites: Shows matches with the transcription
sites in the file Transsites.txt.
- Direct repeats: Shows up to 20 direct repeats.
- TransSiteModifier: The value (between min and max) of
the TransSiteModifier.
- CpGModifier: The value (between min and max) of the CpGModifier.
- SplitOctamerModifier: The value (between min and max)
of the SplitOctamerModifier.


Toggle navigation
ee
Gym Club
主页
个人中心
Welcome to
Gym Club
运动如花绽放快乐
校园
青春似火燃烧亮丽
人生
Coach List
all coach
my coach
all subject
basketball
football
swim
wushu
Name
Subject
Status
Text ...
Text ...
reserved
«
←
→
»
ALL RIGHTS RESERVED. COPYRIGHT © 2019
youngyang
- More Information
HomePage


{% extends 'event_layout.html' %} {% block event_content %}
ModFest 1.15 was a Fabric modding event that ran from March 28th to April 5th.
At the end of ModFest 1.15, {{ event.entry_count }} mods were released.


Home
>
HTML5
>
Form Labeling
Checkbox - Implicit Labeling
Select the foods that you eat daily
Daily Foods
Beef
Chicken
Ham
Eggs


Flag semaphore is a technique used for visual communication, where the positions of two flags represent a single letter.
I often see these at puzzle hunts disguised as clock hands, tree branches, dance moves, etc., and I'm very slow at reading the lookup chart (see image at right). I thought the ideal way to decode semaphore would be to draw out the actual angles. So I wrote my own visual semaphore decoder, implemented using Vue.
It's very rare to solve just one semaphore - usually you need to solve many to form a word or a phrase. So I added the ability to push each letter to a text box, using . (period) for quick entry. It's a regular text input, so you can type normally if you want to change anything.
There is also a quick link to anagram the resulting letters on Nutrimatic, which is a very powerful pattern-matching tool. If you're familiar with Nutrimatic syntax, you can use it here as well - for example, if you're not quite sure what a semaphore position is, you can enter capital A for "any letter", and hope that Nutrimatic will be able to fill it in for you.
Note that this decoder does not decode numerals, which are typically represented with the (0, 45) signal followed by another signal.
More writing on how this project was made:
The Making of Semaphore Decoder.


Character Creator
Home
Character Sheet
About The Team
Choose your race:
Human
Elf
Dwarf
Orc
Halfling
Player name:
Character name:
Gender:
Male
Female
Pick a Class:
Fighter
Ranger
Druid
Cleric
Wizard
Rogue
Provide a valid image url for an avatar picture (png, jpg, jpeg):
Write your character's bio:
Ability
Points
Mod
Cost
Racial Traits
Actual Points
Actual Mod
Strength
0
0
0
0
0
Dexterity
0
0
0
0
0
Constitution
0
0
0
0
0
Intelligence
0
0
0
0
0
Wisdom
0
0
0
0
0
Charism
0
0
0
0
0
20
Points Available
Remove a Player:
Xxxx
remove a Player's Character:
Xxxx


Utility functions for writing XLLs
Microsoft Excel Developer's Toolkit Version 15.0
Microsoft Excel Developer's Toolkit Version 14.0
Code from generic.h and generic.d Ported to the D Programming Language by Laeeth Isharc (2015) This module provides the ceremony that must be done for every XLL. At least one module must be linked to this one implementing the getWorkSheetFunctions function so that they can be registered with Excel.


--- layout: blank --- Daisy Garden   profile blogs albums Skills Resume @daisyHawen Git @知乎
@daisyHawen


Do You Want More From Our Stands?
Our stands offer salmon shirts for our fans.. so you can remember us as long as you wearing them
With every purchase from our stands you will get a salmon sticker that you can buy more if you want to remember us every time tou see these stickers


This is not a game of chess.
Send someone a link to this page. Or start something new.
Fork (pun intended) unmoved on GitHub.


{% extends "base.html" %} {% from "security/_macros.html" import render_field_with_errors, render_field %} {% include "security/_messages.html" %} {% block body %}
A confirmation mail will be sent to the address registered below.
{% include "security/_menu.html" %}


---
layout: post
title: stressed is desserts spelled backwards
date: 2011-12-16 05:21:37.000000000 -05:00
type: post
published: true
status: publish
categories:
- college
- cookies
tags:
- chocolate chips
- cookies
- nutella
- oatmeal
- pb
- stress
meta:
_edit_last: '1'
author:
login: sophie
email<EMAIL_ADDRESS>display_name: Pika
first_name: ''
last_name: ''
---
Don't get me wrong, I love my alma mater-to-be, but sometimes, being at the nation's number one stressed school has its downsides.
Like staying up all night on the weekends...studying.
Like that time class was cancelled...and people stayed on anyway, to participate in "intellectual discussion".
Like that genius kid who ruins the curve in calculus by getting a 100 on every test.
Like when you have 2 projects and a lab due during finals week, with 4 finals to go. (Now. Sorry I've been MIA on the blog.)
Good thing a wise man once (should have) said, when life gives you stress, make cookies!
Peanut butter cookies.
Two kinds.
Peanut Butter Chocolate Chip Oatmeal Cookies
With whole wheat flour, oatmeal, and peanut butter, these are cookies are wholesome yet seriously addictive!
They have great texture: crispy outside, soft melty inside, full of chocolate chips & pb.
- ½ c pb
- ½ c brown sugar
- 1 large egg
- ¼ c whole wheat flour
- ¼ c oatmeal
- ¼ t cinnamon
- ½ t baking soda
- ¼ c chocolate chips
- Preheat oven to 350F and grease a baking sheet.
- In a large bowl, mix pb and brown sugar until smooth. Beat in egg.
- Stir in flour, then mix in oats, baking soda, and cinnamon. Fold in chocolate chips. Don’t overmix!
- Scoop out tablespoons of dough, place on baking sheet, and flatten slightly.
- Bake for 10-12 min, or until tops are lightly golden.
- Cool on a wire rack. Cookies may be stored in an airtight container for 3-4 days...if they last!
Peanut Butter-Nutella Thumbprints
Makes about 15 cookies
Adapted from
That’s So Vegan
Nutella and peanut butter: one dream team. These cookies are sooo good, with a melt-in-mouth honey-scented dough and rich filling. I made them for my school newspaper's Secret Santa and they were quite well received!
- 1 c AP flour
- ½ t baking soda
- ½ t salt
- ½ c pb
- ½ c honey
- ⅙ c oil
- 1 t vanilla
- Nutella for filling (about ½ c)
- Preheat oven to 350F and line 2 cookie sheets.
- In a medium bowl, mix flour, baking soda, and salt.
- In a large bowl, stir together pb, honey, oil, and vanilla until creamy. Stir in dry ingredients until combined.
- Roll tbs of dough into balls and place on baking sheets.
- Bake for about 8-10 min, or until lightly browned.
- Make indents with thumb, and fill with Nutella!
- Cool completely before serving.


{% include navbar.html %}
{% include github-star-btn.html %}
Dexie.js
A Minimalistic Wrapper for IndexedDB
( only ~22k minified and gzipped )
Get started in 30 seconds
Get started
Fiddle
{{ content }}
{% include google-analytics.html %}


{% extends "layout/default.html" %} {% load static chameleon_tags bootstrap3 %} {% block title %}Edit Profile{% endblock %} {% block content %}
You have requested PI Eligibility. The Chameleon accounting team is reviewing your request.
Please provide a link to your institution's department directory or any other official institution page where information confirming your current appointment can be found.
Users who intend to create and lead projects on Chameleon must meet the PI Eligibility requirements. Please review the PI Eligibility requirements to determine if you qualify as PI Eligible.


Welcome to Enot Hub
Here we store prebuilt Erlang packages, just like Maven does for java ;).
Last built packages| Fullname | Version | Build Date |
|---|---|---|
Server version: not installed
Enot: not installed
Kerl: not installed
Here we store prebuilt Erlang packages, just like Maven does for java ;).
Last built packages| Fullname | Version | Build Date |
|---|---|---|
Server version: not installed
Enot: not installed
Kerl: not installed


Not Connected
Connected
There's no
#&togetherjs=SESSION_ID
in the URL.
Restart recording
Select record
/* TogetherJS session starts */


Spark Streaming Programming Guide
- Overview
- Linking with Spark Streaming
- Initializing Spark Streaming
- Attaching Input Sources - InputDStreams
- DStream Operations
- Starting the Streaming computation
- Example
- DStream Persistence
- RDD Checkpointing within DStreams
- Performance Tuning
- Fault-tolerance Properties
- Java API
- Where to Go from Here
Overview
A Spark Streaming application is very similar to a Spark application; it consists of a driver program that runs the user’s main
function and continuous executes various parallel operations on input streams of data. The main abstraction Spark Streaming provides is a discretized stream (DStream), which is a continuous sequence of RDDs (distributed collections of elements) representing a continuous stream of data. DStreams can be created from live incoming data (such as data from a socket, Kafka, etc.) or can be generated by transforming existing DStreams using parallel operators like map
, reduce
, and window
. The basic processing model is as follows:
(i) While a Spark Streaming driver program is running, the system receives data from various sources and and divides it into batches. Each batch of data is treated as an RDD, that is, an immutable parallel collection of data. These input RDDs are saved in memory and replicated to two nodes for fault-tolerance. This sequence of RDDs is collectively called an InputDStream.
(ii) Data received by InputDStreams are processed using DStream operations. Since all data is represented as RDDs and all DStream operations as RDD operations, data is automatically recovered in the event of node failures.
This guide shows some how to start programming with DStreams.
Linking with Spark Streaming
Add the following SBT or Maven dependency to your project to use Spark Streaming:
groupId = org.apache.spark
artifactId = spark-streaming_2.9.3
version = 0.8.1-incubating
Initializing Spark Streaming
The first thing a Spark Streaming program must do is create a StreamingContext
object, which tells Spark how to access a cluster. A StreamingContext
can be created by using
new StreamingContext(master, appName, batchDuration, [sparkHome], [jars])
The master
parameter is a standard Spark cluster URL and can be “local” for local testing. The appName
is a name of your program, which will be shown on your cluster’s web UI. The batchDuration
is the size of the batches (as explained earlier). This must be set carefully such that the cluster can keep up with the processing of the data streams. Start with something conservative like 5 seconds. See the Performance Tuning section for a detailed discussion. Finally, sparkHome
and jars
are necessary when running on a cluster to specify the location of your code, as described in the Spark programming guide.
This constructor creates a SparkContext for your job as well, which can be accessed with streamingContext.sparkContext
.
Attaching Input Sources - InputDStreams
The StreamingContext is used to creating InputDStreams from input sources:
// Assuming ssc is the StreamingContext
ssc.textFileStream(directory) // Creates a stream by monitoring and processing new files in a HDFS directory
ssc.socketStream(hostname, port) // Creates a stream that uses a TCP socket to read data from hostname:port
We also provide a input streams for Kafka, Flume, Akka actor, etc. For a complete list of input streams, take a look at the StreamingContext API documentation.
DStream Operations
Data received from the input streams can be processed using DStream operations. There are two kinds of operations - transformations and output operations. Similar to RDD transformations, DStream transformations operate on one or more DStreams to create new DStreams with transformed data. After applying a sequence of transformations to the input streams, you’ll need to call the output operations, which writies data out to an external source.
Transformations
DStreams support many of the transformations available on normal Spark RDD’s:
| Transformation | Meaning |
|---|---|
| map(func) | Returns a new DStream formed by passing each element of the source DStream through a function func. |
| filter(func) | Returns a new DStream formed by selecting those elements of the source DStream on which func returns true. |
| flatMap(func) | Similar to map, but each input item can be mapped to 0 or more output items (so func should return a Seq rather than a single item). |
| mapPartitions(func) | Similar to map, but runs separately on each partition (block) of the DStream, so func must be of type Iterator[T] => Iterator[U] when running on an DStream of type T. |
| repartition(numPartitions) | Changes the level of parallelism in this DStream by creating more or fewer partitions. |
| union(otherStream) | Return a new DStream that contains the union of the elements in the source DStream and the argument DStream. |
| count() | Returns a new DStream of single-element RDDs by counting the number of elements in each RDD of the source DStream. |
| reduce(func) | Returns a new DStream of single-element RDDs by aggregating the elements in each RDD of the source DStream using a function func (which takes two arguments and returns one). The function should be associative so that it can be computed in parallel. |
| countByValue() | When called on a DStream of elements of type K, returns a new DStream of (K, Long) pairs where the value of each key is its frequency in each RDD of the source DStream. |
| groupByKey([numTasks]) | When called on a DStream of (K, V) pairs, returns a new DStream of (K, Seq[V]) pairs by grouping together all the values of each key in the RDDs of the source DStream. Note: By default, this uses Spark's default number of parallel tasks (2 for local machine, 8 for a cluster) to do the grouping. You can pass an optional numTasks argument to set a different number of tasks.
|
| reduceByKey(func, [numTasks]) | When called on a DStream of (K, V) pairs, returns a new DStream of (K, V) pairs where the values for each key are aggregated using the given reduce function. Like in groupByKey , the number of reduce tasks is configurable through an optional second argument. |
| join(otherStream, [numTasks]) | When called on two DStreams of (K, V) and (K, W) pairs, returns a new DStream of (K, (V, W)) pairs with all pairs of elements for each key. |
| cogroup(otherStream, [numTasks]) | When called on DStream of (K, V) and (K, W) pairs, returns a new DStream of (K, Seq[V], Seq[W]) tuples. |
| transform(func) | Returns a new DStream by applying func (a RDD-to-RDD function) to every RDD of the stream. This can be used to do arbitrary RDD operations on the DStream. |
| updateStateByKey(func) | Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of each key. This can be used to track session state by using the session-id as the key and updating the session state as new data is received. |
Spark Streaming features windowed computations, which allow you to apply transformations over a sliding window of data. All window functions take a windowDuration, which represents the width of the window and a slideTime, which represents the frequency during which the window is calculated.
| Transformation | Meaning |
|---|---|
| window(windowDuration, slideDuration) | Return a new DStream which is computed based on windowed batches of the source DStream. windowDuration is the width of the window and slideTime is the frequency during which the window is calculated. Both times must be multiples of the batch interval. |
| countByWindow(windowDuration, slideDuration) | Return a sliding count of elements in the stream. windowDuration and slideDuration are exactly as defined in window() .
|
| reduceByWindow(func, windowDuration, slideDuration) | Return a new single-element stream, created by aggregating elements in the stream over a sliding interval using func. The function should be associative so that it can be computed correctly in parallel. windowDuration and slideDuration are exactly as defined in window() .
|
| groupByKeyAndWindow(windowDuration, slideDuration, [numTasks]) | When called on a DStream of (K, V) pairs, returns a new DStream of (K, Seq[V]) pairs by grouping together values of each key over batches in a sliding window. Note: By default, this uses Spark's default number of parallel tasks (2 for local machine, 8 for a cluster) to do the grouping. You can pass an optional numTasks argument to set a different number of tasks. |
| reduceByKeyAndWindow(func, windowDuration, slideDuration, [numTasks]) | When called on a DStream of (K, V) pairs, returns a new DStream of (K, V) pairs where the values for each key are aggregated using the given reduce function func over batches in a sliding window. Like in groupByKeyAndWindow , the number of reduce tasks is configurable through an optional second argument.
windowDuration and slideDuration are exactly as defined in window() .
|
| reduceByKeyAndWindow(func, invFunc, windowDuration, slideDuration, [numTasks]) | A more efficient version of the above reduceByKeyAndWindow() where the reduce value of each window is calculated
incrementally using the reduce values of the previous window. This is done by reducing the new data that enter the sliding window, and "inverse reducing" the old data that leave the window. An example would be that of "adding" and "subtracting" counts of keys as the window slides. However, it is applicable to only "invertible reduce functions", that is, those reduce functions which have a corresponding "inverse reduce" function (taken as parameter invFunc. Like in groupByKeyAndWindow , the number of reduce tasks is configurable through an optional second argument.
windowDuration and slideDuration are exactly as defined in window() .
|
| countByValueAndWindow(windowDuration, slideDuration, [numTasks]) | When called on a DStream of (K, V) pairs, returns a new DStream of (K, Long) pairs where the value of each key is its frequency within a sliding window. Like in groupByKeyAndWindow , the number of reduce tasks is configurable through an optional second argument.
windowDuration and slideDuration are exactly as defined in window() .
|
A complete list of DStream operations is available in the API documentation of DStream and PairDStreamFunctions.
Output Operations
When an output operator is called, it triggers the computation of a stream. Currently the following output operators are defined:
| Operator | Meaning |
|---|---|
| foreach(func) | The fundamental output operator. Applies a function, func, to each RDD generated from the stream. This function should have side effects, such as printing output, saving the RDD to external files, or writing it over the network to an external system. |
| print() | Prints first ten elements of every batch of data in a DStream on the driver. |
| saveAsObjectFiles(prefix, [suffix]) | Save this DStream's contents as a SequenceFile of serialized objects. The file name at each batch interval is generated based on prefix and suffix: "prefix-TIME_IN_MS[.suffix]".
|
| saveAsTextFiles(prefix, [suffix]) | Save this DStream's contents as a text files. The file name at each batch interval is generated based on prefix and suffix: "prefix-TIME_IN_MS[.suffix]". |
| saveAsHadoopFiles(prefix, [suffix]) | Save this DStream's contents as a Hadoop file. The file name at each batch interval is generated based on prefix and suffix: "prefix-TIME_IN_MS[.suffix]". |
Starting the Streaming computation
All the above DStream operations are completely lazy, that is, the operations will start executing only after the context is started by using
ssc.start()
Conversely, the computation can be stopped by using
ssc.stop()
Example
A simple example to start off is the NetworkWordCount. This example counts the words received from a network server every second. Given below is the relevant sections of the source code. You can find the full source code in <Spark repo>/streaming/src/main/scala/org/apache/spark/streaming/examples/NetworkWordCount.scala
.
import org.apache.spark.streaming.{Seconds, StreamingContext}
import StreamingContext._
...
// Create the context and set up a network input stream to receive from a host:port
val ssc = new StreamingContext(args(0), "NetworkWordCount", Seconds(1))
val lines = ssc.socketTextStream(args(1), args(2).toInt)
// Split the lines into words, count them, and print some of the counts on the master
val words = lines.flatMap(_.split(" "))
val wordCounts = words.map(x => (x, 1)).reduceByKey(_ + _)
wordCounts.print()
// Start the computation
ssc.start()
The socketTextStream
returns a DStream of lines received from a TCP socket-based source. The lines
DStream is transformed into a DStream using the flatMap
operation, where each line is split into words. This words
DStream is then mapped to a DStream of (word, 1)
pairs, which is finally reduced to get the word counts. wordCounts.print()
will print 10 of the counts generated every second.
To run this example on your local machine, you need to first run a Netcat server by using
$ nc -lk 9999
Then, in a different terminal, you can start NetworkWordCount by using
$ ./run-example org.apache.spark.streaming.examples.NetworkWordCount local[2] localhost 9999
This will make NetworkWordCount connect to the netcat server. Any lines typed in the terminal running the netcat server will be counted and printed on screen.
|
|
You can find more examples in <Spark repo>/streaming/src/main/scala/org/apache/spark/streaming/examples/
. They can be run in the similar manner using ./run-example org.apache.spark.streaming.examples....
. Executing without any parameter would give the required parameter list. Further explanation to run them can be found in comments in the files.
DStream Persistence
Similar to RDDs, DStreams also allow developers to persist the stream’s data in memory. That is, using persist()
method on a DStream would automatically persist every RDD of that DStream in memory. This is useful if the data in the DStream will be computed multiple times (e.g., multiple operations on the same data). For window-based operations like reduceByWindow
and reduceByKeyAndWindow
and state-based operations like updateStateByKey
, this is implicitly true. Hence, DStreams generated by window-based operations are automatically persisted in memory, without the developer calling persist()
.
For input streams that receive data from the network (that is, subclasses of NetworkInputDStream like FlumeInputDStream and KafkaInputDStream), the default persistence level is set to replicate the data to two nodes for fault-tolerance.
Note that, unlike RDDs, the default persistence level of DStreams keeps the data serialized in memory. This is further discussed in the Performance Tuning section. More information on different persistence levels can be found in Spark Programming Guide.
RDD Checkpointing within DStreams
A stateful operation is one which operates over multiple batches of data. This includes all window-based operations and the updateStateByKey
operation.
Because stateful operations have a dependency on previous batches of data, they continuously accumulate metadata over time. To clear this metadata, streaming supports periodic checkpointing by saving intermediate data to HDFS. Note that checkpointing also incurs the cost of saving to HDFS which may cause the corresponding batch to take longer to process. Hence, the interval of checkpointing needs to be set carefully. At small batch sizes (say 1 second), checkpointing every batch may significantly reduce operation throughput. Conversely, checkpointing too slowly causes the lineage and task sizes to grow which may have detrimental effects. Typically, a checkpoint interval of 5 - 10 times of sliding interval of a DStream is good setting to try.
To enable checkpointing, the developer has to provide the HDFS path to which RDD will be saved. This is done by using
ssc.checkpoint(hdfsPath) // assuming ssc is the StreamingContext
The interval of checkpointing of a DStream can be set by using
dstream.checkpoint(checkpointInterval) // checkpointInterval must be a multiple of slide duration of dstream
For DStreams that must be checkpointed (that is, DStreams created by updateStateByKey
and reduceByKeyAndWindow
with inverse function), the checkpoint interval of the DStream is by default set to a multiple of the DStream’s sliding interval such that its at least 10 seconds.
Custom Receivers
Spark comes with a built in support for most common usage scenarios where input stream source can be either a network socket stream to support for a few message queues. Apart from that it is also possible to supply your own custom receiver via a convenient API. Find more details at Custom Receiver Guide.
Performance Tuning
Getting the best performance of a Spark Streaming application on a cluster requires a bit of tuning. This section explains a number of the parameters and configurations that can tuned to improve the performance of you application. At a high level, you need to consider two things:
- Reducing the processing time of each batch of data by efficiently using cluster resources.
- Setting the right batch size such that the data processing can keep up with the data ingestion.
Reducing the Processing Time of each Batch
There are a number of optimizations that can be done in Spark to minimize the processing time of each batch. These have been discussed in detail in Tuning Guide. This section highlights some of the most important ones.
Level of Parallelism
Cluster resources maybe under-utilized if the number of parallel tasks used in any stage of the computation is not high enough. For example, for distributed reduce operations like reduceByKey
and reduceByKeyAndWindow
, the default number of parallel tasks is 8. You can pass the level of parallelism as an argument (see the PairDStreamFunctions
documentation), or set the system property spark.default.parallelism
to change the default.
Data Serialization
The overhead of data serialization can be significant, especially when sub-second batch sizes are to be achieved. There are two aspects to it.
-
Serialization of RDD data in Spark: Please refer to the detailed discussion on data serialization in the Tuning Guide. However, note that unlike Spark, by default RDDs are persisted as serialized byte arrays to minimize pauses related to GC.
-
Serialization of input data: To ingest external data into Spark, data received as bytes (say, from the network) needs to deserialized from bytes and re-serialized into Spark’s serialization format. Hence, the deserialization overhead of input data may be a bottleneck.
Task Launching Overheads
If the number of tasks launched per second is high (say, 50 or more per second), then the overhead of sending out tasks to the slaves maybe significant and will make it hard to achieve sub-second latencies. The overhead can be reduced by the following changes:
-
Task Serialization: Using Kryo serialization for serializing tasks can reduced the task sizes, and therefore reduce the time taken to send them to the slaves.
-
Execution mode: Running Spark in Standalone mode or coarse-grained Mesos mode leads to better task launch times than the fine-grained Mesos mode. Please refer to the Running on Mesos guide for more details. These changes may reduce batch processing time by 100s of milliseconds, thus allowing sub-second batch size to be viable.
Setting the Right Batch Size
For a Spark Streaming application running on a cluster to be stable, the processing of the data streams must keep up with the rate of ingestion of the data streams. Depending on the type of computation, the batch size used may have significant impact on the rate of ingestion that can be sustained by the Spark Streaming application on a fixed cluster resources. For example, let us consider the earlier WordCountNetwork example. For a particular data rate, the system may be able to keep up with reporting word counts every 2 seconds (i.e., batch size of 2 seconds), but not every 500 milliseconds.
A good approach to figure out the right batch size for your application is to test it with a conservative batch size (say, 5-10 seconds) and a low data rate. To verify whether the system is able to keep up with data rate, you can check the value of the end-to-end delay experienced by each processed batch (in the Spark master logs, find the line having the phrase “Total delay”). If the delay is maintained to be less than the batch size, then system is stable. Otherwise, if the delay is continuously increasing, it means that the system is unable to keep up and it therefore unstable. Once you have an idea of a stable configuration, you can try increasing the data rate and/or reducing the batch size. Note that momentary increase in the delay due to temporary data rate increases maybe fine as long as the delay reduces back to a low value (i.e., less than batch size).
24/7 Operation
By default, Spark does not forget any of the metadata (RDDs generated, stages processed, etc.). But for a Spark Streaming application to operate 24/7, it is necessary for Spark to do periodic cleanup of it metadata. This can be enabled by setting the Java system property spark.cleaner.ttl
to the number of seconds you want any metadata to persist. For example, setting spark.cleaner.ttl
to 600 would cause Spark periodically cleanup all metadata and persisted RDDs that are older than 10 minutes. Note, that this property needs to be set before the SparkContext is created.
This value is closely tied with any window operation that is being used. Any window operation would require the input data to be persisted in memory for at least the duration of the window. Hence it is necessary to set the delay to at least the value of the largest window operation used in the Spark Streaming application. If this delay is set too low, the application will throw an exception saying so.
Memory Tuning
Tuning the memory usage and GC behavior of Spark applications have been discussed in great detail in the Tuning Guide. It is recommended that you read that. In this section, we highlight a few customizations that are strongly recommended to minimize GC related pauses in Spark Streaming applications and achieving more consistent batch processing times.
-
Default persistence level of DStreams: Unlike RDDs, the default persistence level of DStreams serializes the data in memory (that is, StorageLevel.MEMORY_ONLY_SER for DStream compared to StorageLevel.MEMORY_ONLY for RDDs). Even though keeping the data serialized incurs a higher serialization overheads, it significantly reduces GC pauses.
-
Concurrent garbage collector: Using the concurrent mark-and-sweep GC further minimizes the variability of GC pauses. Even though concurrent GC is known to reduce the overall processing throughput of the system, its use is still recommended to achieve more consistent batch processing times.
Fault-tolerance Properties
In this section, we are going to discuss the behavior of Spark Streaming application in the event of a node failure. To understand this, let us remember the basic fault-tolerance properties of Spark’s RDDs.
- An RDD is an immutable, and deterministically re-computable, distributed dataset. Each RDD remembers the lineage of deterministic operations that were used on a fault-tolerant input dataset to create it.
- If any partition of an RDD is lost due to a worker node failure, then that partition can be re-computed from the original fault-tolerant dataset using the lineage of operations.
Since all data transformations in Spark Streaming are based on RDD operations, as long as the input dataset is present, all intermediate data can recomputed. Keeping these properties in mind, we are going to discuss the failure semantics in more detail.
Failure of a Worker Node
There are two failure behaviors based on which input sources are used.
- Using HDFS files as input source - Since the data is reliably stored on HDFS, all data can re-computed and therefore no data will be lost due to any failure.
- Using any input source that receives data through a network - For network-based data sources like Kafka and Flume, the received input data is replicated in memory between nodes of the cluster (default replication factor is 2). So if a worker node fails, then the system can recompute the lost from the the left over copy of the input data. However, if the worker node where a network receiver was running fails, then a tiny bit of data may be lost, that is, the data received by the system but not yet replicated to other node(s). The receiver will be started on a different node and it will continue to receive data.
Since all data is modeled as RDDs with their lineage of deterministic operations, any recomputation always leads to the same result. As a result, all DStream transformations are guaranteed to have exactly-once semantics. That is, the final transformed result will be same even if there were was a worker node failure. However, output operations (like foreach
) have at-least once semantics, that is, the transformed data may get written to an external entity more than once in the event of a worker failure. While this is acceptable for saving to HDFS using the saveAs*Files
operations (as the file will simply get over-written by the same data), additional transactions-like mechanisms may be necessary to achieve exactly-once semantics for output operations.
Failure of the Driver Node
A system that is required to operate 24/7 needs to be able tolerate the failure of the driver node as well. Spark Streaming does this by saving the state of the DStream computation periodically to a HDFS file, that can be used to restart the streaming computation in the event of a failure of the driver node. This checkpointing is enabled by setting a HDFS directory for checkpointing using ssc.checkpoint(<checkpoint directory>)
as described earlier. To elaborate, the following state is periodically saved to a file.
- The DStream operator graph (input streams, output streams, etc.)
- The configuration of each DStream (checkpoint interval, etc.)
- The RDD checkpoint files of each DStream
All this is periodically saved in the file <checkpoint directory>/graph
. To recover, a new Streaming Context can be created with this directory by using
val ssc = new StreamingContext(checkpointDirectory)
On calling ssc.start()
on this new context, the following steps are taken by the system
- Schedule the transformations and output operations for all the time steps between the time when the driver failed and when it last checkpointed. This is also done for those time steps that were previously scheduled but not processed due to the failure. This will make the system recompute all the intermediate data from the checkpointed RDD files, etc.
- Restart the network receivers, if any, and continue receiving new data.
In the current alpha release, there are two different failure behaviors based on which input sources are used.
- Using HDFS files as input source - Since the data is reliably stored on HDFS, all data can re-computed and therefore no data will be lost due to any failure.
- Using any input source that receives data through a network - The received input data is replicated in memory to multiple nodes. Since, all the data in the Spark worker’s memory is lost when the Spark driver fails, the past input data will not be accessible and driver recovers. Hence, if stateful and window-based operations are used (like
updateStateByKey
,window
,countByValueAndWindow
, etc.), then the intermediate state will not be recovered completely.
In future releases, we will support full recoverability for all input sources. Note that for non-stateful transformations like map
, count
, and reduceByKey
, with all input streams, the system, upon restarting, will continue to receive and process new data.
To better understand the behavior of the system under driver failure with a HDFS source, lets consider what will happen with a file input stream Specifically, in the case of the file input stream, it will correctly identify new files that were created while the driver was down and process them in the same way as it would have if the driver had not failed. To explain further in the case of file input stream, we shall use an example. Lets say, files are being generated every second, and a Spark Streaming program reads every new file and output the number of lines in the file. This is what the sequence of outputs would be with and without a driver failure.
| Time | Number of lines in input file | Output without driver failure | Output with driver failure |
|---|---|---|---|
| 1 | 10 | 10 | 10 |
| 2 | 20 | 20 | 20 |
| 3 | 30 | 30 | 30 |
| 4 | 40 | 40 | [DRIVER FAILS] no output |
| 5 | 50 | 50 | no output |
| 6 | 60 | 60 | no output |
| 7 | 70 | 70 | [DRIVER RECOVERS] 40, 50, 60, 70 |
| 8 | 80 | 80 | 80 |
| 9 | 90 | 90 | 90 |
| 10 | 100 | 100 | 100 |
If the driver had crashed in the middle of the processing of time 3, then it will process time 3 and output 30 after recovery.
Java API
Similar to Spark’s Java API, we also provide a Java API for Spark Streaming which allows all its features to be accessible from a Java program. This is defined in [org.apache.spark.streaming.api.java] (api/streaming/index.html#org.apache.spark.streaming.api.java.package) package and includes JavaStreamingContext and JavaDStream classes that provide the same methods as their Scala counterparts, but take Java functions (that is, Function, and Function2) and return Java data and collection types. Some of the key points to note are:
- Functions for transformations must be implemented as subclasses of Function and Function2
- Unlike the Scala API, the Java API handles DStreams for key-value pairs using a separate JavaPairDStream class(similar to JavaRDD and JavaPairRDD. DStream functions like
map
andfilter
are implemented separately by JavaDStreams and JavaPairDStream to return DStreams of appropriate types.
Spark’s Java Programming Guide gives more ideas about using the Java API. To extends the ideas presented for the RDDs to DStreams, we present parts of the Java version of the same NetworkWordCount example presented above. The full source code is given at <spark repo>/examples/src/main/java/org/apache/spark/streaming/examples/JavaNetworkWordCount.java
The streaming context and the socket stream from input source is started by using a JavaStreamingContext
, that has the same parameters and provides the same input streams as its Scala counterpart.
JavaStreamingContext ssc = new JavaStreamingContext(mesosUrl, "NetworkWordCount", Seconds(1));
JavaDStream<String> lines = ssc.socketTextStream(ip, port);
Then the lines
are split into words by using the flatMap
function and FlatMapFunction.
JavaDStream<String> words = lines.flatMap(
new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String x) {
return Lists.newArrayList(x.split(" "));
}
});
The words
is then mapped to a JavaPairDStream of (word, 1)
pairs using map
and PairFunction. This is reduced by using reduceByKey
and Function2.
JavaPairDStream<String, Integer> wordCounts = words.map(
new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String s) throws Exception {
return new Tuple2<String, Integer>(s, 1);
}
}).reduceByKey(
new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer i1, Integer i2) throws Exception {
return i1 + i2;
}
});
Where to Go from Here
- API docs - Scala and Java
- More examples - Scala and Java
- Paper describing Spark Streaming


Welcome to FormsForEducation!
After installing the Add-on into a Spreadsheet, you have to initialize the necessary configurations.
This is done by opening the Add-ons > FormsForEducation
menu then
clicking Initialize
.
After doing this, you are ready to configure your Question Banks!
Question Banks are your Google Drive Folders that have multiple Forms with questions.
These are collections of questions about the same subject that will be randomly chosen for your students.
It's a good idea to have them with the same level of difficulty, to avoid situations where students can get easier or harder questions. If you want to have multiple levels of difficulty for the same subject, consider creating one Question Bank per level ("Math - Easy" and "Math - Hard").
There are some important things to consider when creating your question bank:
For more assistance, go to the Add-ons > FormsForEducation > Help
menu then select the option that reflects what help you need.


Path to the checkpoint directory.
Disposes of any untracked Tensors
to avoid GPU memory leaks.
Loads variables from the checkpoint and builds the model graph.
Returns true iff model is intialized.
Predicts LogMelMagnitudes and IFreq from latent (z) and pitch conditioning.
A 4-D Tensor of latent (z) concatenated with one-hot pitch conditioning. Size [batch, 1, 1, nLatents].
Size of input batch.
a 4-D Tensor size [batch, time, freq, ch]. First channel is LogMelSpectrogram and second channel is InstantaneousFrequency.
Creates one random sample of LogMelSpecgram and IFreq from integer pitch.
Integer MIDI pitch number of sound to generate.
specgrams a 4-D Tensor size [batch, time, freq, ch]. First channel is LogMelSpectrogram and second channel is InstantaneousFrequency.
Include specgramsToAudio as a member method for API/export.
a 4-D Tensor size [batch, time, freq, ch]. First channel is LogMelSpectrogram and second channel is InstantaneousFrequency.
Float32Array of audio samples for first specgram in the batch.
Generated using TypeDoc
GANSynth
constructor.


Equipment
All the equipment used on this route. All equipment may not be present on every schedule.


We're sorry but Puerto Rico | Top Headlines In US doesn't work properly without JavaScript enabled. Please enable it to continue.


@()
Words about Database Flow
-
Here's some words about Database Flow, maybe a slogan or something.
-
An opinionated modern database interface.
-
Running locally or on a shared server, Database Flow helps you discover and search your database from a browser.
-
Database Flow is self hosted, so your data always remains private.
-
The big advantages DBF has over it's competition:
- - Installed locally or on a server, DBF doesn't need internet access.
- - Websocket-driven communications, for zero-latency and persistent connections.
- - Full retina support, and a Material Design implementation that scales from a phone to dual 4K monitors.
- - Supports the most popular half dozen databases, and adding more is easy (for me).
- - Explain plan is visualized in a pretty novel way.
- - Uses the best charting library, webgl/svg support.
-
Database Flow was created by a solo developer.
I'm always looking for new ways to improve the product, and would love any feedback you can provide.
-
Marketing is my Achilles' heel, so I'd particularly love some input on how to effectively sell and market Database Flow.


Click on parent org units to collapse or reveal their children.
Click on any org unit to autopopulate its path in the Edit OUs Console.
Use your mouse wheel to zoom in & zoom out on the visualization.
Click and drag your mouse to reposition the diagram.


{% extends 'layout.html' %} {% load static %} {% load otis_extras %} {% block layout-content %}
This is Idle-Warn, where you can find a list of students who have yet to submit the first problem set, or have not submitted a problem set for a while. Be gentle! Don't be the bad guy.
| Lv | Name | Latest PSet Date | Format | Units | |||
|---|---|---|---|---|---|---|---|
| {{ student|level }} | {{ student.name }} | {% if student.latest_pset %}{{ student.latest_pset|date:"Y-m-d" }} | {{ student.latest_pset|date:"H:i" }} | {% else %}None | {% endif%}{{ student.get_track }} | {{ student.num_psets|default_if_none:0 }} |
This list was generated {% now "r" %}.
{% endblock %}


This is the taste you will never forget.
| Type | Size | ||
|---|---|---|---|
| Small Pizza | Medium Pizza | Large Pizza | |
| Cheese-stuffed crust | 500 | 1000 | 1500 |
| Pizza bagels | 400 | 800 | 1200 |
| Thin crust | 700 | 1400 | 2100 |
| Silicon style | 800 | 1600 | 2400 |
| Neapolitan crust | 1000 | 2000 | 3000 |
| Toppings | Price(Ksh) |
|---|---|
| Cheese | 100 |
| Sausage and bacon | 150 |
| Anchovies | 150 |
| Mixed sliced mushrooms | 110 |
How many pizzas would you like to enjoy?
Do you wish to have your pizza delivered to you?
Where do you live?


Before Change
if arch == "resnet18":
orig_resnet = resnet.__dict__["resnet18"](pretrained=pretrained)
net_encoder = Resnet(orig_resnet)
elif arch == "resnet18_dilated8":
orig_resnet = resnet.__dict__["resnet18"](pretrained=pretrained)
net_encoder = ResnetDilated(orig_resnet,
dilate_scale=8)
elif arch == "resnet18_dilated16":
orig_resnet = resnet.__dict__["resnet18"](pretrained=pretrained)
net_encoder = ResnetDilated(orig_resnet,
dilate_scale=16)
elif arch == "resnet34":
raise NotImplementedError
orig_resnet = resnet.__dict__["resnet34"](pretrained=pretrained)
net_encoder = Resnet(orig_resnet)
elif arch == "resnet34_dilated8":
raise NotImplementedError
orig_resnet = resnet.__dict__["resnet34"](pretrained=pretrained)
net_encoder = ResnetDilated(orig_resnet,
dilate_scale=8)
elif arch == "resnet34_dilated16":
raise NotImplementedError
orig_resnet = resnet.__dict__["resnet34"](pretrained=pretrained)
net_encoder = ResnetDilated(orig_resnet,
dilate_scale=16)
elif arch == "resnet50":
orig_resnet = resnet.__dict__["resnet50"](pretrained=pretrained)
net_encoder = Resnet(orig_resnet)
elif arch == "resnet50_dilated8":
orig_resnet = resnet.__dict__["resnet50"](pretrained=pretrained)
net_encoder = ResnetDilated(orig_resnet,
dilate_scale=8)
elif arch == "resnet50_dilated16":
orig_resnet = resnet.__dict__["resnet50"](pretrained=pretrained)
net_encoder = ResnetDilated(orig_resnet,
dilate_scale=16)
elif arch == "resnet101":
orig_resnet = resnet.__dict__["resnet101"](pretrained=pretrained)
After Change
def build_encoder(self, arch="resnet50dilated", fc_dim=512, weights=""):
pretrained = True if len(weights) == 0 else False
arch = arch.lower()
if arch == "resnet18":
orig_resnet = resnet.__dict__["resnet18"](pretrained=pretrained)
net_encoder = Resnet(orig_resnet)
elif arch == "resnet18dilated":


If we continue to type some pointless ramblings, I would like to show you my ability to emphasize text using italics. This is a phenomenon that is quite different from bolding text, which is generally used in school textbooks to clearly identify random terms that a student must memorize for his or her exams.
But what about other headings?
You've asked a good question, my son. Here is a list to help you identify them all:
- heading 6, a useless heading no one uses
- heading 5, another useless heading that is very rarely used
- heading 4, a heading that is used sometimes in lengthy articles
I should like to show you an image, this image startled me when I first discovered it; I hope you are sitting down and ready.
Making use of an h4 doot!
Ask to be pet then attack owners hand intently sniff hand, for thug cat . Chase ball of string love and coo around boyfriend who purrs and makes the perfect moonlight eyes so i can purr and swat the glittery gleaming yarn to him (the yarn is from a $125 sweater) so make meme, make cute face, but meow go back to sleep owner brings food and water tries to pet on head, so scratch get sprayed by water because bad cat and fall asleep upside-down. Lick left leg for ninety minutes, still dirty have a lot of grump in yourself because you can't forget to be grumpy and not be like king grumpy cat. Reward the chosen human with a slow blink wack the mini furry mouse stare at wall turn and meow stare at wall some more meow again continue staring , i love cuddles, friends are not food.
This is an h5 doot.
Ask to be pet then attack owners hand intently sniff hand, for thug cat . Chase ball of string love and coo around boyfriend who purrs and makes the perfect moonlight eyes so i can purr and swat the glittery gleaming yarn to him (the yarn is from a $125 sweater) so make meme, make cute face, but meow go back to sleep owner brings food and water tries to pet on head, so scratch get sprayed by water because bad cat and fall asleep upside-down. Lick left leg for ninety minutes, still dirty have a lot of grump in yourself because you can't forget to be grumpy and not be like king grumpy cat. Reward the chosen human with a slow blink wack the mini furry mouse stare at wall turn and meow stare at wall some more meow again continue staring , i love cuddles, friends are not food.
A useless h6 doot, that's right. Totally pointless.
Ask to be pet then attack owners hand intently sniff hand, for thug cat . Chase ball of string love and coo around boyfriend who purrs and makes the perfect moonlight eyes so i can purr and swat the glittery gleaming yarn to him (the yarn is from a $125 sweater) so make meme, make cute face, but meow go back to sleep owner brings food and water tries to pet on head, so scratch get sprayed by water because bad cat and fall asleep upside-down. Lick left leg for ninety minutes, still dirty have a lot of grump in yourself because you can't forget to be grumpy and not be like king grumpy cat. Reward the chosen human with a slow blink wack the mini furry mouse stare at wall turn and meow stare at wall some more meow again continue staring , i love cuddles, friends are not food.
- Numbered list doot #1
- Numbered list doot #2
- Numbered list doot #3


Advertiser content is used to describe advertisement features that are paid for, produced and controlled by the advertiser rather than the publisher.
They are subject to regulation by the Advertising Standards Authority in the UK, the Federal Trade Commission in the US and the Advertising Standards Bureau in Australia.
This content is produced by the advertiser and does not involve GNM staff.
This content was paid for and produced by Renault. For more information click
Advertiser content is used to describe advertisement features that are paid for, produced and controlled by the advertiser rather than the publisher.
They are subject to regulation by the Advertising Standards Authority in the UK, the Federal Trade Commission in the US and the Advertising Standards Bureau in Australia.
This content is produced by the advertiser and does not involve GNM staff.


What even is this app? How do I use it? Why would I?
Playlisted:
Audio Bliss
To find the soundtrack of your life.
Playlisted is a music application to discover and create the perfect playlist to fit a mood/activity level! Your first step towards finding the playlist of your dreams is to sign up for an account.
After you join the Playlisted community, create your perfect playlists by selecting a mood, energy level, and genre. The personalized song recommendations are purpose built with you in mind. Don't like what you hear? Change it and rearrange it! Customize any playlists with ease. Once you have the perfect fit, save your playlist and listen on!


Opening Time
- Sunday-Wednesday: 06:30 - 10:00
- Thursday: 08:00 - 11:30
- Friday: Closed
Holisticly implement economically sound applications for extensible innovation. Completely syndicate e-business technology after robust scenarios. Dramatically incentivize B2C quality vectors before real time resources. Professionally enable efficient synergy through virtual benefits.
Authoritatively conceptualize robust tailers rather than top-line growth strategies. Efficiently visualize leading-edge growth strategies via sticky imperatives.
Read More


|
AceTime
2.3.0
Date and time classes for Arduino that support timezones from the TZ Database.
|
A time zone transition rule. More...
#include <ZoneInfoMid.h>
Public Attributes | |
| int16_t const | fromYear |
| FROM year. | |
| int16_t const | toYear |
| TO year. | |
| uint8_t const | inMonth |
| Determined by the IN column. More... | |
| uint8_t const | onDayOfWeek |
| Determined by the ON column. More... | |
| int8_t const | onDayOfMonth |
| Determined by the ON column. More... | |
| uint8_t const | atTimeCode |
| Determined by the AT column in units of 15-minutes from 00:00. More... | |
| uint8_t const | atTimeModifier |
| The atTimeModifier is a packed field containing 2 pieces of info: More... | |
| uint8_t const | deltaCode |
| Determined by the SAVE column and contains the offset from UTC, in 15-min increments. More... | |
| uint8_t const | letterIndex |
| Determined by the LETTER column. More... | |
A time zone transition rule.
It is useful to think of this as a transition rule that repeats on the given (month, day, hour) every year during the interval [fromYear, toYear] inclusive.
Definition at line 95 of file ZoneInfoMid.h.
| uint8_t const ace_time::zoneinfomid::ZoneRule< S >::atTimeCode |
Determined by the AT column in units of 15-minutes from 00:00.
The range is (0 - 100) corresponding to 00:00 to 25:00.
Definition at line 127 of file ZoneInfoMid.h.
| uint8_t const ace_time::zoneinfomid::ZoneRule< S >::atTimeModifier |
The atTimeModifier is a packed field containing 2 pieces of info:
Definition at line 138 of file ZoneInfoMid.h.
| uint8_t const ace_time::zoneinfomid::ZoneRule< S >::deltaCode |
Determined by the SAVE column and contains the offset from UTC, in 15-min increments.
The deltaCode is equal to (originalDeltaCode + 4). Only the lower 4-bits is used, for consistency with the ZoneEra::deltaCode field. This allows the 4-bits to represent DST offsets from -1:00 to 2:45 in 15-minute increments.
The ZonePolicyBroker::deltaMinutes() method knows how to convert this field into minutes.
Definition at line 150 of file ZoneInfoMid.h.
| uint8_t const ace_time::zoneinfomid::ZoneRule< S >::inMonth |
| uint8_t const ace_time::zoneinfomid::ZoneRule< S >::letterIndex |
Determined by the LETTER column.
Determines the substitution into the 's' field (implemented here by just a '') of the ZoneInfo::format field. This is an index offset into the global kLetters array. Most LETTER string is a single character, e.g. "D", "S", or "". But a small number have LETTER fields which are longer than one character. For example:
Definition at line 164 of file ZoneInfoMid.h.
| int8_t const ace_time::zoneinfomid::ZoneRule< S >::onDayOfMonth |
Determined by the ON column.
Used with onDayOfWeek. Possible values are: 0, 1-31, or its corresponding negative values.
Definition at line 121 of file ZoneInfoMid.h.
| uint8_t const ace_time::zoneinfomid::ZoneRule< S >::onDayOfWeek |
Determined by the ON column.
Possible values are: 0, 1=Mon, 7=Sun. There are 4 combinations:
* onDayOfWeek=0, onDayOfMonth=(1-31): exact match * onDayOfWeek=1-7, onDayOfMonth=1-31: dayOfWeek>=dayOfMonth * onDayOfWeek=1-7, onDayOfMonth=-(1-31): dayOfWeek<=dayOfMonth * onDayOfWeek=1-7, onDayOfMonth=0: last{dayOfWeek} *
Definition at line 115 of file ZoneInfoMid.h.


In her post, she mentioned that she was on an outing with some friends when some guys took advantage of her drunken state to have sex with her and taped the moment.
Surprisingly the tape got to her boyfriend who is now threatening to leak it online.
Read her post:
Origin…
I met my boyfriend in school actually we were in the same department at funnab. We did things together. We were in love and had sex when we feel like it. We planned to get married after school.
Mistake…
I went to a birthday party of one of my close friends, I had three friends and we are like clique.
 During the act I know what was happening but was too weak and blurred. I didn’t know there was a video recording of the act. When I woke up the guy was no where to be found so I kept it to myself.
Blackmail…
When my guy found out that I cheated on him, he was furious. I denied it initially but when he showed me the sex clip I admitted it but defended myself on the ground that it was rape and not consensual. I summon courage and asked him how did he come up with the sex tape but that he would not answer to. He left that moment and I start feeling that he knows something about the tape and wants to blackmail.
Threat…
He showed up one day at my hostel and threaten to leak the tape online. I begged him profusely not to do that but he said my plea and tears are waste of time. That he will let everyone know the kind of loose lady I am for betraying and cheating on him. That I will regret the day I met him. That I doesn’t deserve his love.
Currently…
He is yet to release the clip but may actually do that with what is happening to the Babcock ex student.
What should I do to stop him before he destroys me.
Follow us on Facebook – @Lailasnews; Twitter – @LailaIjeoma for updates


For Layla
When they returned as the wolf packs, the herds on the move, and willows slowed the flow. This, in turn, created space to return. These builders needed to raise their families. The animals that depended on the riparian meadows came back, as well. The wolves exert their influence on the landscape. My hope is that the wolves enter my world.


Search Google Books
full text available
ebook available
Searching...
No books found.
Try adjusting your search by removing filters.
Results


Labour leader Corbyn would be 'neutral' in another Brexit vote
LONODN: British Labour leader Jeremy Corbyn on Friday (Nov 22) revealed for the first time that he will remain neutral in the second Brexit referendum that he has vowed to hold if he becomes prime minister next month.
"I will adopt a neutral stance so I can credibly carry out the result," he told a special edition of the BBC's Question Time programme.
Labour plans to renegotiate the deal agreed between the current Conservative government and the European Union, and then put it to another vote, with remaining in the EU being the other option.
"This will be a trade deal with Europe, or remaining in the EU," he added. "That will be the choice that we put before the British public within six months."
Some Labour MPs have said they will vote against their own party's deal and in favour of staying in the EU.
It is the first time that Corbyn, a veteran eurosceptic who has not revealed how he would vote in another referendum, has stated how he will campaign.
The Brexit issue is threatening to hurt Labour in its traditional working class heartlands, which mostly voted to leave the EU.
Prime Minister Boris Johnson is hoping to pick up stray Labour leave voters, but suffered a difficult night in front of an unforgiving crowd.
Johnson came under fire for alleged racism in his previous news articles and also for not releasing a report into Russian interference in the 2016 Brexit referendum, which he dismissed as "Bermuda Triangle stuff".
Corbyn's route to power in the Dec 12 election could depend on support from the Scottish National Party (SNP) in some form of coalition.
SNP leader Nicola Sturgeon said in the BBC debate that another referendum on Scottish independence from the United Kingdom would be the price of her support.
"I would ask for, and expect, Jeremy Corbyn to respect the right of Scottish people to decide their own future."
The Labour leader earlier said that a Scottish independence referendum was "not a priority" in the "early years" of his administration, which he defined as being two years.
But Sturgeon told the audience that she was "not sure he's going to compromise the chance" of becoming prime minister by holding out on the SNP's demands.


This controls the disk consumption of Hudson by managing how long you'd like to keep
records of the builds (such as console output, build artifacts, and so on.)
Hudson offers two criteria:
-
Driven by age. You can have Hudson delete a record if it reaches a certain age
(for example, 7 days old.)
-
Driven by number. You can have Hudson make sure that it only maintains up to
N build records. If a new build is started, the oldest record will
be simply removed.
Hudson also allows you to mark an individual build as 'Keep this log forever', to
exclude certain important builds from being discarded automatically.
The last stable and last successful build are always kept as well.
It's possible to use Project cascading feature for this property. Please review
this document.


There was an old lady who swallowed a fly;
I don't know why she swallowed a fly - perhaps she'll die
There was an old lady who swallowed a spider;


SkyGamer Web
I make free open source games.
VISIT https://github.com/SkyCoder123/SkyGamer-Web/blob/master/LICENSE for details of the aproppriate license (MIT License).
Games


Audio Input Demo
Tested on Chrome. Example uses bootstrap for styling, but you can use whatever you want.


Last name
First name
Adress
City
State
ZIP/Postal Code
Country
Bulgaria
USA
Turkey
Australia
Phone (country code,area code,number)
+(
)
-
Email
Birth date
Month
Day
Year(4 digit)
Gender
Male
Female
Starting date
Spring 2006
Summer 2006
Comment/Questions


{% extends "base.html" %} {% block title %}这是个Test页面{% endblock %} {% block stylesheets %}{% endblock %} {% block scripts %} {% endblock %} {% block header%}testtesttest{% endblock %} {% block container %}
Some quick example text to build on the card title and make up the bulk of the card's content.
Card link Another linkSome quick example text to build on the card title and make up the bulk of the card's content.
Card link Another link


7.5 psb_get_mpi_rank — Get the MPI rank
rank = psb_get_mpi_rank(ctxt, id)
This function returns the MPI rank of the PSBLAS process id
-
Type:
- Asynchronous.
-
On Entry
-
-
ctxt
- the communication context identifying the virtual parallel machine.
Scope: global.
Type: required.
Intent: in.
Specified as: an integer variable.
-
id
- Identifier of a process in the PSBLAS virtual parallel machine.
Scope: local.
Type: required.
Intent: in.
Specified as: an integer value. 0 ≤ id ≤ np - 1
-
On Return
-
-
Funciton value
- The MPI rank associated with the PSBLAS process id.
Scope: local.
Type: required.
Intent: out.
Notes The subroutine version psb_get_rank is still available but is deprecated.


Introducing for the first time ever
100% Automated CPN Process!
HOME
CONTACT US
LOGIN
REGISTER
100% Automated Process


Lead of Imaging AI - Bay Area, CA - Redwood City, CA
Here at Tempus we believe the greatest promise for the detection and treatment of cancer & other diseases lies in building a deep understanding of the interaction between molecular attributes and clinical treatment. With the advent of genomic sequencing, we can finally measure and process our genetic makeup. We now have more data than ever before, but providers often don't have the infrastructure or expertise required to easily extract the valuable insights that exist within this data. We're on a mission to redefine how the combination of genomic, clinical, and imaging data is used in a clinical setting through precision medicine.
This role is for an experienced leader in the field of computer vision on medical images, for diagnosis, prognosis, and the discovery of new biomarkers. The role will report directly to the SVP of Data Science.
What You Will Do:
Build and lead the Bay Area Imaging AI team, as one of the functional leaders, to translate research into clinically actionable insights for our clients and advance our internal research agenda.
Develop algorithms used to gain insight into disease prognostics through analysis of large sets of clinical data.
Collaborate closely with other functional leads as well as product, engineering, and business development as well as other imaging teams.
Guide the team's direction and technical roadmap, mentor junior members - while also being hands-on and a strong individual contributor yourself.
Analyze and integrate large diverse clinical, molecular and imaging datasets to extract insights, and drive research opportunities.
Document, summarize, and present your findings to a group of peers and stakeholders.
Provide technical leadership & expertise across multiple modeling projects.
Required Qualifications:
PhD degree in a relevant discipline (e.g. computer vision, machine learning, computer science, applied mathematics, physics, or similar).
Substantial experience working with medical images, in particular pathology WSIs, CT, MRIs.
Expert level knowledge of machine learning, pipelines and data handling, DICOM, imaging modalities, common artifacts, etc.
Expert level knowledge of modern computer vision algorithms, including CNNs, RNNs, segmentation networks, 3D imaging.
8+ years of relevant industry experience.
Highest standard of scientific rigor, and an acute awareness to balance high academic quality versus fast-paced product requirements.
Proven ability to lead a medium sized team of 5-10 people.
Outstanding analytical and problem solving skills.
Strong individual track record and hands-on mentality.
Strong technical proficiency in a range of tools such as Python, SciPy, AWS, SageMaker, TensorFlow, PyTorch, etc.
Strong understanding of software best practices to serve as role model for their team and maintain a high level of quality and scalability on the technical as well as scientific side.
Strong peer-reviewed publication record.
Thrive in a fast-paced environment and willing to shift priorities seamlessly.
Experience with communicating insights and presenting concepts to diverse audiences.
Team player mindset and ability to work in an interdisciplinary team.
Goal orientation, self motivation, and drive to make a positive impact in healthcare.
Preferred Qualifications:
Experience in a late-stage startup environment.
Successful history of building and leading a highly functional team from the ground up.
Experience with sensitive patient data and working under HIPAA regulations.
Ability to attract high potential junior as well as senior talent.


Not a Member? Sign Up
Please fill in this form to create an account.
By creating an account you agree to our Terms & Privacy.


Aerospace Engineering and Computer Science student at the University of Southern California.
Hi, my passion lies in aerospace engineering, and my dream is to push the boundaries of human capability in flight and space travel. I also enjoy coding, especially when it's applied in robotics.
A lot of the work I've done in this area has been with design teams, namely USC Aerodesign team and USC Hyperloop
I've done a summer internship with Boeing and another one with a biomedical start-up, both times as a mechanical engineer.
I also do research on flapping wing designs within the USC engineering school.
Tools: NX (Unigraphics), Autodesk Fusion 360, Solidworks, MODO
Languages: Java, C/C++, Python
Development tools: Eclipse, MySQL, Git


The first COVID-19 Data Forum will have two parts, the main public webinar open to all and an invited workshop. We will evaluate our ability to scale the workshop to more people for future meetings.
| Time | Session | Description |
|---|---|---|
| {{ .presentation.time }} | {{ with .photo }} {{ end }} {{ .presentation.title }} {{ .company }} | {{ .presentation.description }} |
| {{ .time }} | {{ .name }} | - |
Joseph Rickert, Chair R Consortium Board of Directors
John Chambers, Stanford Department of Statistics and Stanford Data Science
Michael Kane, Assistant Professor, Department of Biostatistics, Yale University
Balasubramanian Narasimhan, Senior Research Scientist, Department of Biomedical Data Sciences, Stanford University
Chris Mentzel, Executive Director, Stanford Data Science


Network Visualization Tool (NVT) v0.2
Home
Protocol Usage
Destination by Source
Traffic by Destination
Traffic over Time


Know the latest interest rates on education loans from leading banks in India so that you can compare rates and
select the best student loan for your requirements. There are many factors that influence the rate of interest
on these loans. Know what they are and how to calculate your education loan EMI for better financial management.
Also find out all about the eligibility criteria and documents required to ensure that your application has a
greater chance of approval.
|
Banks |
Interest Rates |
Processing Fee |
| PNB |
7.30 to 9.80 p.a. |
1% of loan amount |
| SBI |
7.97% to 10.05% p.a. |
Rs.10000 + tax |
| Axis |
13.70% to 15.20% p.a. |
Nil to Rs.10000 + tax |
| Bank of Baroda |
8.25% to 10% p.a. |
1% of loan amount upto Rs.10000 |
| HDFC |
For Preferential Rates Contact HDFC |
Up to 1.5% of loan amount + tax |
| Tata Capital |
10.99% onwards |
Up to 2.75% of loan amount + tax |
| Union Bank of India |
6.90% onwards |
Nil for Indian Students 0.50% of loan amount for NRI Students + tax |
| Bank of India |
9.10% onwards |
Nil for courses in India Rs.5000 + other fees for study abroad |
| Kotak Mahindra Bank |
Up to 16% |
Contact the Bank |
| ICICI Bank |
Contact the Bank |
Contact the Bank |
| Federal Bank |
10.05% onwards |
Contact the Bank |
Education Loan Egibility:
- Nationality:
-
- Indian Citizens
- Non-Indian Residents (NRIs)
- Overseas Citizens of India (OCI)
- Persons of Indian Origin (PIOs)
- Students born to Indian parents abroad and wish to study in India
- Courses:
-
- Undergraduate programs
- Postgraduate programs
- Doctoral courses and PhDs
- Certificate courses with 6 months or longer duration
- Job-oriented courses
- Technical/diploma/professional courses
- Institutes:
-
- Recognized institutions and government colleges
- Private institutes aided by government
- Professional institutions
- International colleges and universities
- Collateral:
-
- Collateral-free loans up to Rs.7.5 lakh from leading lenders
- Collateral-free loans up to Rs.40 lakh for select courses/institutions from select lenders
Acceptable collateral: Residential or commercial property or plot, fixed deposits, insurance
Loan amount: Up to Rs.1 crore
List of Expenses Covered in Education Loan:
Here’s what the loan amount will cover:
- Tuition fees
- Hostel fees
- Travel expenses passage money for students studying abroad
- Insurance premium
- Cost of books/equipment/instruments/uniform
- Examination/laboratory/library fees
- Cost of a computer/laptop required for course completion
- Caution deposit, building fund/refundable deposit supported by institution bills/receipts
- Any other expense required to complete the course such as study tours/thesis/project work
List of Documents Required For Education Loan
Here is an indicative list of documents that most lenders ask:
- Admission letter from the educational institution
- Marksheets (previous education – school/college)
- Age proof
- ID proof
- Address proof
- Signature proof
- Salary slips
- Recent bank account statements
- ITR with income computation
- Audited balance sheet
- Recent bank statements
- Proof of turnover (service tax return/sales receipt)
- Completed application form with signature
- Latest passport size photographs
- Appropriate Visa for studies abroad
*Document charges may be levied by the lender.


Announcing ML.NET 1.0 RC - Machine Learning for .NET | .NET Blog ML.NET is an open-source and cross-platform machine learning framework (Windows, Linux, macOS) for .NET developers. Using ML.NET, developers can leverage their existing tools and skillsets to develop and infuse custom AI into their applications by creatin...
MAKRO | Microsoft Excel Stream Highlights 3/19 Makro walks you through the latest Microsoft Office365 update. // instagram: https://www.instagram.com/krazam.tv/ // twitter: https://www.twitter.com/krazamtv/ // SFX: http://www.freesfx.co.uk/
DDoS Protection Service | Anti DDoS Mitigation | Cloudflare Mitigate a DDoS attack of any size using Cloudflare's advanced DDoS protection including DNS Amplification, SYN/ACK, Layer 7 Attacks. Don't get ddos attacked!
Proposed changes to Index / Range by jaredpar · Pull Request #2397 · dotnet/csharplang This is a set of proposed changes to the Index and Range features based on customer feedback. Note: when looking at the LDM notes from 4/1 the version of the proposal being discussed is captured he...
Better Obsoletion by terrajobst · Pull Request #62 · dotnet/designs GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together.
brave/brave-browser Next generation Brave browser for macOS, Windows, Linux, and eventually Android - brave/brave-browser
dotnet/dotnet-api-docs .NET API reference documentation (.NET Framework, .NET Core, .NET Standard and Xamarin) - dotnet/dotnet-api-docs
.NET Core Summer Event bij Info Support The .NET Core Summer Event is a 1 day mini-conference focused on software development with .NET Core. The program consists of 12 sessions divided over 2 tracks with an international speaker line-up containing MVPs and members of the .NET Core team at Micr...
Your words are wasted - Scott Hanselman It needs to be said again, perhaps this time more strongly. Your Blog is The Engine of Community. Dammit. Blog More You ...
The Edge of an Infinite Universe Have you ever asked “what is beyond the edge of the universe?” And have you ever been told that an infinite universe that has no edge? You were told wrong. In a sense. We can define a boundary to an infinite universe, at least mathematically. And it turns...
MVVM Development in Visual Studio Take this survey powered by surveymonkey.com. Create your own surveys for free.
SqlCommand.Dispose doesn't free managed object · Issue #74 · dotnet/SqlClient SqlCommand.Dispose contains this code: // release managed objects _cachedMetaData = null; This doesn't free the cached data, which is supposed to be the purpose of the Dispose(Boolean) overload...
 For the last 3 years, my dad has been helping me learn how to code and I'd like to show you the tools we used. Some of them helped me learn to code before I could read, some of them helped me learn when I just wanted to p...
OVERWHELM for Nintendo Switch - Nintendo Game Details OVERWHELM is an action horror-world platformer where enemies power-up and you don’t.
Tom 7 Radar: CHESSBOVIK Survival in chessland is about how to stay alive if you are being a chesspiece to the death
The Witness goes free on the Epic Games Store for two weeks The Witness is free on the Epic Games Store for the next two weeks. Grab now, keep forever. Enjoy Jonathan Blow's surprisingly huge Myst-like puzzler.
ZIO STM by jdegoes · Pull Request #721 · zio/zio Provides a minimal, functional, and reasonably well-tested implementation of Software Transactional Memory for ZIO, closely inspired by and with a similar API to the STM in Haskell. The two core da...
NationalSecurityAgency/ghidra Ghidra is a software reverse engineering (SRE) framework - NationalSecurityAgency/ghidra
Operating Systems: Three Easy Pieces Welcome to Operating Systems: Three Easy Pieces (now version 1.00 -- see book news for details), a free online operating systems book! The book is centered around three conceptual pieces that are fundamental to operating systems: virtualization, concurren...
/diagnostics (Compiler diagnostic options) Use the /diagnostics compiler option to specify the display of error and warning location information.
Bringing GPU acceleration to Windows containers At the release of Windows Server 2019 last year, we announced support for a set of hardware devices in Windows containers. One popular type of device missing support at the time: GPUs. We’ve heard frequent feedback that you want hardware acceleration for ...
The electronic song “Scary Monsters and Nice Sprites” reduces host attack and mating success in the dengue vector Aedes aegypti Sound and its reception are crucial for reproduction, survival, and population maintenance of many animals. In insects, low-frequency vibrations facil…
The Witness - **You wake up, alone, on a strange island full of puzzles.** # These puzzles will challenge and surprise you. # You don't remember who you are, and you don't remember how you got here, but there's one thing you can do: explore the island in hope of discovering clues, regaining your memory, and somehow finding your...