Aggregate Business Tendency Survey Data (and other qualitative surveys) to time series at various aggregation levels. Run aggregation of survey data in a speedy, re-traceable and a easily deployable way. Aggregation is substantially accelerated by use of data.table. This package intends to provide an interface that is less general and abstract than data.table but rather geared towards survey researchers.
| Version: | 0.1.1 |
| Depends: | R (≥ 3.0.0), data.table (≥ 1.9.4) |
| Published: | 2017-01-07 |
| Author: | Matthias Bannert [aut, cre], Gabriel Bucur [aut] |
| Maintainer: | Matthias Bannert <bannert at kof.ethz.ch> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| Materials: | README |
| In views: | OfficialStatistics |
| CRAN checks: | panelaggregation results |
| Reference manual: | panelaggregation.pdf |
| Package source: | panelaggregation_0.1.1.tar.gz |
| Windows binaries: | r-devel: panelaggregation_0.1.1.zip, r-release: panelaggregation_0.1.1.zip, r-oldrel: panelaggregation_0.1.1.zip |
| OS X binaries: | r-release: panelaggregation_0.1.1.tgz, r-oldrel: panelaggregation_0.1.1.tgz |
| Old sources: | panelaggregation archive |
Please use the canonical form https://CRAN.R-project.org/package=panelaggregation to link to this page.


Enumeration
SwiftSymbolParseError
public enum SwiftSymbolParseError
A type for representing the different possible failure conditions when using ScalarScanner
Relationships
Conforms To
Error
Enumeration Cases
utf8ParseError
case utf8ParseError
Attempted to convert the buffer to UnicodeScalars but the buffer contained invalid data
unexpected
case unexpected(at: Int)
The scalar at the specified index doesn't match the expected grammar
matchFailed
case matchFailed(wanted: String, at: Int)
Expected wanted
at offset at
expectedInt
case expectedInt(at: Int)
Expected numerals at offset at
endedPrematurely
case endedPrematurely(count: Int, at: Int)
Attempted to read count
scalars from position at
but hit the end of the sequence
searchFailed
case searchFailed(wanted: String, after: Int)
Unable to find search patter wanted
at or after after
in the sequence
integerOverflow
case integerOverflow(at: Int)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Note that this demo just shows how to shuffle the order property of a flex/grid item, but item position in DOM is not changed.
Make sure you've opened the DevTools Inspector and watch Elements tab, while clicking on "Shuffle Cards" button.


|
blmc_drivers
|
CanBusInterface is an abstract class that defines an API for the communication via Can bus. More...
#include <can_bus.hpp>
Public Types | |
| typedef real_time_tools::ThreadsafeTimeseries< CanBusFrame > | CanframeTimeseries |
| CanframeTimeseries is a simple sohortcut. | |
Public Member Functions | |
| virtual | ~CanBusInterface () |
| Destroy the CanBusInterface object. | |
| virtual std::shared_ptr< const CanframeTimeseries > | get_output_frame () const =0 |
| getters More... | |
| virtual std::shared_ptr< const CanframeTimeseries > | get_input_frame ()=0 |
| Get the input frame. More... | |
| virtual std::shared_ptr< const CanframeTimeseries > | get_sent_input_frame ()=0 |
| Get the sent input frame. More... | |
| virtual void | set_input_frame (const CanBusFrame &input_frame)=0 |
| setters More... | |
| virtual void | send_if_input_changed ()=0 |
| Sender. More... | |
CanBusInterface is an abstract class that defines an API for the communication via Can bus.
|
pure virtual |
Get the input frame.
Implemented in blmc_drivers::CanBus.
|
pure virtual |
getters
Get the output frame
Implemented in blmc_drivers::CanBus.
|
pure virtual |
Get the sent input frame.
Implemented in blmc_drivers::CanBus.
|
pure virtual |
|
pure virtual |
setters
Set the input frame saves the input frame to be sent in a queue.
| input_frame |
Implemented in blmc_drivers::CanBus.


Avengers: Endgame Concept Art Offers First Hi-Res Look at Gorilla Chitauri
by Dan ConnerConcept art from the final fight in Avengers: Endgame displays the lumbering gorilla Chitauri in high resolution for the first time.
Featuring a significant amount of detail and featuring the designs from multiple angles, Marvel concept artist Jerad S. Marantz posted up-close shots of the beasts to his Instagram. With the images, Marantz shared, "Funny story, I was in between characters on Spiderman Far from Home and got this assignment. They were rethinking this character/creature in the final battle in #endgame and needed a new design...I got it approved in the first pass. It was really exciting to work on #endgame again after so much time."
Click the button below to start this article in quick view.
Describing the pictures, which feature the gorilla Chitauri's advanced armor, Marantz noted, "I’m not sure how this guy fits in the alien race, he’s either a less involved version of the #Chitauri or some genetically modified version for battle."
We also recently got a look at concept art for baby Thanos along with versions of the Mad Titan as a teenager. Given the scope of the massive MCU film, expect a lot more discarded concepts and detailed looks at elements from the movie to continue pouring in.
Directed by Joe and Anthony Russo, Avengers: Endgame stars Robert Downey Jr. as Iron Man, Chris Evans as Captain America, Mark Ruffalo as Bruce Banner, Chris Hemsworth as Thor, Scarlett Johansson as Black Widow, Jeremy Renner as Hawkeye, Brie Larson as Captain Marvel, Paul Rudd as Ant-Man, Don Cheadle as War Machine, Karen Gillan as Nebula, Danai Gurira as Okoye and Bradley Cooper as Rocket, with Gwyneth Paltrow Pepper Potts, Jon Favreau as Happy Hogan, Benedict Wong as Wong, Tessa Thompson as Valkyrie and Josh Brolin as Thanos. The film is available on Digital HD, Blu-ray and 4K UHD.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2Movieshttps://www.cbr.com/category/movies/ListItem3Movie Newshttps://www.cbr.com/category/movies/news-movies/ListItem4Avengers: Endgame Concept Art Offers First Hi-Res Look at Gorilla Chitaurihttps://www.cbr.com/avengers-endgame-concept-art-gorilla-chitauri/


|
NetBeans UML Modeling |
org::galagosearch::core::index::IndexReader
public class IndexReader
This implements the core functionality for all inverted list readers. It can also be used as a read-only TreeMap for disk-based data structures. In Galago, it is used both to store index data and to store documents.
An index is a mapping from String to byte[]. If compression is turned on, the value must be small enough that it fits in memory. If compression is off, values are streamed directly from disk so there is no size restriction. Indexes support iteration over all keys, or direct lookup of a single key. The structure is optimized to support fast random lookup on disks.
Data is stored in blocks, typically 32K each. Each block has a prefix-compressed set of keys at the beginning, followed by a block of value data. IndexWriter/IndexReader can GZip compress that value data, or it can be stored uncompressed. For inverted list data it's best to use your own compression, but for text data the GZip compression is a good choice.
Typically this class is extended by composition instead of inheritance.
@author trevor| Properties | |
|---|---|
| Alias | IndexReader |
| Visibility | public |
| Final | |
| Transient | |
| Abstract | |
| Leaf |
| Nested Class Summary | |
|---|---|
private class |
VocabularyBlock
  |
public class |
Iterator
  |
| Attribute Summary | |
|---|---|
RandomAccessFile |
input
  |
Parameters |
manifest
  |
int |
blockSize
  |
int |
vocabGroup
  |
long |
vocabularyOffset
  |
long |
manifestOffset
  |
long |
footerOffset
  |
boolean |
isCompressed
  |
| Constructor Summary | |
|---|---|
IndexReader(String pathname) Opens an index found in the at pathname. |
|
IndexReader(File pathname) Identical to the {@link #IndexReader(String) other constructor}, except this one takes a File object instead of a string as the parameter. |
| Operation Summary | |
|---|---|
boolean |
isIndexFile(String pathname) Returns true if the file specified by this pathname was probably written by IndexWriter. |
VocabularyReader |
getVocabulary() Returns the vocabulary structure for this IndexReader. |
Iterator |
getIterator() Returns an iterator pointing to the very first key in the index. |
Iterator |
getIterator(String key) Returns an iterator pointing at a specific key. |
String |
getValueString(String key) Gets the value stored in the index associated with this key. |
DataStream |
getValueStream(String key) Gets the value stored in the index associated with this key. |
Parameters |
getManifest() Returns a Parameters object that contains metadata about the contents of the index. |
DataStream |
blockStream(long len) Like the other blockStream variant, but this one uses the current file location as the starting offset. |
DataStream |
blockStream(long offset, long length) This convenience method returns a DataStream for a region of an inverted file. |
DataStream |
blockStream(Iterator iter) This convenience method returns a DataStream for the region of the inverted file pointed to by the iterator. |
RandomAccessFile |
getInput() Returns the file object for the inverted file. |
void |
close() Closes all files associated with the IndexReader. |
VocabularyBlock |
readVocabularyBlock(long slotBegin) Reads vocabulary data from a block of the inverted file. |
| Attribute Detail |
|---|
package RandomAccessFile input
package Parameters manifest
package int blockSize
package int vocabGroup
package long vocabularyOffset
package long manifestOffset
package long footerOffset
package boolean isCompressed
| Constructor Detail |
|---|
public IndexReader(String pathname)
public IndexReader(File pathname)
| Operation Detail |
|---|
public static boolean isIndexFile(String pathname)
public VocabularyReader getVocabulary()
public Iterator getIterator()
public Iterator getIterator(String key)
public String getValueString(String key)
public DataStream getValueStream(String key)
public Parameters getManifest()
public DataStream blockStream(long len)
public DataStream blockStream(long offset, long length)
public DataStream blockStream(Iterator iter)
public RandomAccessFile getInput()
public void close()
package VocabularyBlock readVocabularyBlock(long slotBegin)
|
NetBeans UML Modeling |


Optimizing CTR with Deep Learning
2015-2017
This is a project I started on sophomore year at Purdue through an NSF Research Experiences for Undergraduates grant 1246818. This would not been possible without the Statistics Living Learning Community that I was part of that year, headed by Prof. Mark Daniel Ward.
The project I worked is based on the fact that a large part of electronic retail relies on understanding consumer product interests. This has led to the development of mathematical models in advertisement agencies to predict if the consumer they are targeting will click on their advertisement. Achieving the highest click prediction rate would mean that these agencies can pay to place their on line advertisements effectively to target people most interested in their product. Most of these predictions are based on regression models. Our goal was to utilize deep learning models to achieve better scores than the known regression models.
The data that we used was from the iPinYou competition, where competitors were tasked to build a model that would achieve a high click through rate (CTR). iPinYou provided advertisement data from 9 companies. For each instance in the data we were given various attributes of the person that the electronic advertisement was sent to as well as if the person clicked on the advertisement. The data was originally split into different seasons of the iPinYou competition so the data for each advertiser had to be aggregated. After that, some of the variables had to be removed, spliced, or one hot encoded.
Once we had our data we tested our predictive power using a convolutional neural net and then a neural network model. Using our model configuration, we were not able to achieve higher predictive power than the regressions we compared it to, but the way we arranged our data made our models more interpretable to further analysis.
I was advised by Dr. Xiao Wang and Dr. Quiang Liu at Purdue. The results are going to be published in JPUR 2017.


The ContactLabel control displays up to three phone numbers and one email address for a patient. If phone or email data is not entered, the label will be displayed with blank space next to it.
Additional information relating to this control can be found on the corresponding MSCUI control page.


Company Leaderboard
-Weekly Report
RBC
60%
TD
35%
| Employer | TD |
| Join Date | 06/23/2013 |
| Date of Birth | 01/24/1988 |
| Gender | Female |
| Home Address | Ontario, Canada |
|<EMAIL_ADDRESS>| Phone Number | 123-4567-890(Landline) 555-4567-890(Mobile) |


Time Converter
DISTANCE
25
50
100
200
Meters
Yards
TIME
0
1
2
3
4
5
6
Min
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
Sec
.00
.01
.02
.03
.04
.05
.06
.07
.08
.09
.10
.11
.12
.13
.14
.15
.16
.17
.18
.19
.20
.21
.22
.23
.24
.25
.26
.27
.28
.29
.30
.31
.32
.33
.34
.35
.36
.37
.38
.39
.40
.41
.42
.43
.44
.45
.46
.47
.48
.49
.50
.51
.52
.53
.54
.55
.56
.57
.58
.59
.60
.61
.62
.63
.64
.65
.66
.67
.68
.69
.70
.71
.72
.73
.74
.75
.76
.77
.78
.79
.80
.81
.82
.83
.84
.85
.86
.87
.88
.89
.90
.91
.92
.93
.94
.95
.96
.97
.98
.99
Centi
Convert To Seminole
repeat
Seminole pool in Madison, WI is a 26.5 Meter pool
Using Seminole Pool's distance of 26.5 Meters, your
swim would have taken:
.


scriptingbundle:metadata
Full name:
org.apache.sling:scriptingbundle-maven-plugin:0.5.0:metadata
Description:
The
metadata
goal will generate two Maven project
properties, namely
org.apache.sling.scriptingbundle.maven.plugin.Require-Capability
and
org.apache.sling.scriptingbundle.maven.plugin.Provide-Capability
which can be used to generate the corresponding OSGi bundle headers
for bundles providing scripts executable by a
ScriptEngine
.Attributes:
- Requires a Maven project to be executed.
- Binds by default to the lifecycle phase:
prepare-package
.
Optional Parameters
| Name | Type | Since | Description |
|---|---|---|---|
<excludes> |
String[] |
0.2.0 |
Allows defining a list of excluded files and folders or patterns to
filter which files should be excluded in the analysis for
generating capabilities.
The following list provides the default excluded files and patterns:
User property is: scriptingbundle.excludes . |
<includes> |
String[] |
0.2.0 |
Allows defining a list of included files and folders or patterns to
filter which files should be included in the analysis for
generating capabilities. By default all files are included. Default value is: ** .User property is: scriptingbundle.includes . |
<missingRequirementsOptional> |
boolean |
0.5.0 |
When set to "true", the requirements which are not satisfied
directly by this project will be marked as optional. Default value is: true .User property is: scriptingbundle.missingRequirementsOptional . |
<scriptEngineMappings> |
Map |
0.2.0 |
Allows overriding the default extension to script engine mapping,
in order to correctly generate the
sling.resourceType;scriptEngine
Provide-Capability attribute value. When configuring
this mapping, please make sure to use the script extension as the
key and one of the Script Engine's names (obtained from
ScriptEngineFactory.getNames() ) as the value.
The following list represents the default extension to Script Engine mapping:
|
<searchPaths> |
Set |
0.2.0 |
Allows overriding the default search paths (/apps and
/libs ). When scripts are organised in folders which
follow the search path structure, the Mojo will generate two
resource types for each resource type folder. For example:
src/main/scripts/apps/org/apache/sling/example/example.html org/apache/sling/example /apps/org/apache/sling/example src/main/scripts/org/apache/sling/example/example.html org/apache/sling/example User property is: scriptingbundle.searchPaths . |
<sourceDirectories> |
Set |
0.2.0 |
Defines where this goal will look for scripts in the project. By
default the src/main/scripts and
src/main/resources/javax.script folders will be
considered.User property is: scriptingbundle.sourceDirectories . |
Parameter Details
<excludes>
Allows defining a list of excluded files and folders or patterns to
filter which files should be excluded in the analysis for
generating capabilities.
The following list provides the default excluded files and patterns:
- Miscellaneous typical temporary files
- **/*~, **/#*#, **/.#*, **/%*%, **/._*
- CVS
- **/CVS, **/CVS/**, **/.cvsignore
- Subversion
- **/.svn, **/.svn/**
- Bazaar
- **/.bzr, **/.bzr/**
- Mac
- **/.DS_Store
- Mercurial
- **/.hg, **/.hg/**
- git
- **/.git, **/.git/**
- Type:
java.lang.String[]
- Since:
0.2.0
- Required:
No
- User Property:
scriptingbundle.excludes
<includes>
Allows defining a list of included files and folders or patterns to
filter which files should be included in the analysis for
generating capabilities. By default all files are included.
- Type:
java.lang.String[]
- Since:
0.2.0
- Required:
No
- User Property:
scriptingbundle.includes
- Default:
**
<missingRequirementsOptional>
When set to "true", the requirements which are not satisfied
directly by this project will be marked as optional.
- Type:
boolean
- Since:
0.5.0
- Required:
No
- User Property:
scriptingbundle.missingRequirementsOptional
- Default:
true
<scriptEngineMappings>
Allows overriding the default extension to script engine mapping,
in order to correctly generate the
sling.resourceType;scriptEngine
Provide-Capability
attribute value. When configuring
this mapping, please make sure to use the script extension as the
key and one of the Script Engine's names (obtained from
ScriptEngineFactory.getNames()
) as the value.
The following list represents the default extension to Script Engine mapping:
- ftl
- freemarker
- gst
- gstring
- html
- htl
- java
- java
- esp, ecma
- rhino
- jsp, jspf, jspx
- jsp
- Type:
java.util.Map
- Since:
0.2.0
- Required:
No
<searchPaths>
Allows overriding the default search paths (
will generate the following two resource types
However, the following script
will generate only one resource type
/apps
and
/libs
). When scripts are organised in folders which
follow the search path structure, the Mojo will generate two
resource types for each resource type folder. For example:
src/main/scripts/apps/org/apache/sling/example/example.html
org/apache/sling/example /apps/org/apache/sling/example
src/main/scripts/org/apache/sling/example/example.html
org/apache/sling/example
- Type:
java.util.Set
- Since:
0.2.0
- Required:
No
- User Property:
scriptingbundle.searchPaths
<sourceDirectories>
Defines where this goal will look for scripts in the project. By
default the
src/main/scripts
and
src/main/resources/javax.script
folders will be
considered.- Type:
java.util.Set
- Since:
0.2.0
- Required:
No
- User Property:
scriptingbundle.sourceDirectories


The tabs widget is an implementation of tabbed pages and tabs. Page transitions are animated and the direction of the animation depends on the prder of the tabs associated - if a page is changed from a tab on the right to a page with tab on the left, the reversed animation will be played. Otherwise, if from left to right, the forward animation will be used. The active tab is highlighted. If many tab are defined and they exceed the width of the widget, they will become scrollable.
In addition, tabs can be used for page navigation (see the page widget documentation for more info) as well.
This documentation will cover the tabs, tablist, tab, tabview and tab-page widgets because together they form the whole tabs widget's features list.

<input type="radio" name="taba"/>

First tab

<input type="radio" name="taba"/>

Second tab

First page

Some content is supposed to come here.

Second page

Some content is supposed to come here.

<input type="radio" name="tabb"/>

1st page

<input type="radio" name="tabb"/>

2nd page

...

PAGE 1

Some content is supposed to come here.

PAGE 2

Some content is supposed to come here.

All options are accessible throught the getOption and setOptions method of the widget [tabsMarkupElement.tabs], [tablistMarkupElement.tablist], [tabMarkupElement.tab], [tabviewMarkupElement.tabview] or [tabpageMarkupElement.tabPage] objects. After setting any of the options of the tabs, tablst, tab, tabview or tab-page widget, it will be unenhanced and enhanced to apply the newly set options.
Please use the theme method of the widget to read the current theme.
HTML-Markup notation: data-theme
JavaScript notation: theme
The theme name as string to be used for the widget. Possible values 'a' or 'b'. By default, 'a' stays for dark theme, while 'b' for the bright theme. If omitted, the widget will inherit the theme from its parent.
HTML-Markup notation: data-corners
JavaScript notation: corners
Possible values:
The corners of the widget will be rectangular.
The corners of the widget will be smoothed.
Default is: smooth
HTML-Markup notation: data-active-tab
JavaScript notation: activeTab
The ID of the tab which should be active upon widget initialization. Default is empty string.
HTML-Markup notation: data-position
JavaScript notation: position
Possible values:
The tabs will be placed above the tab view.
The tabs will be placed below the tab view.
Default is: top
HTML-Markup notation: data-center-tabs
JavaScript notation: centerTabs
If set to yes, the tabs will be horizontally centered above/below (depending on the position option) the tab view.
HTML-Markup notation: data-target
JavaScript notation: target
The ID of the tab-page or page which should be displayed upon tab click. This option should be provided and be a non-empty string.
HTML-Markup notation: data-position
JavaScript notation: position
Possible values:
A tab with text and eventually an icon on the left or right of the text.
A tab with an icon on the center and small subscript text below.
Default is: normal
HTML-Markup notation: data-mark
JavaScript notation: mark
Possible values:
If active, the tab will be underlined.
If active, the tab content will be highlighted and underlined.
Default is: underscore
HTML-Markup notation: data-animation
JavaScript notation: animation
The animation to be used for the active tab-page to appear and disappear. Possible values are: "none", "fade", "pop", "slideleft", "slideright", "slidefade", "slideup", "slidedown", "leftmenu", "rightmenu", "upmenu", "downmenu", "flow", "flip" and "turn".
Default is "none".
Sets/Gets the active tab for the current tab list. If the method is called without arguments, the method will return the currently set active tab.
Returns the ID of the tab-page or page the tab is pointing to.
Returns true if the tab-page is active and loaded.
Fired to the tablist when the active tab has changed.
Please click on the links bellow to see the different live examples. All links will open in a new window. Once a link has opened, you can view the source code of the example.


get_scans¶
-
Data_Reduction.DSN.Tid_ASCII_data.
get_scans
(path, groups, group_index)¶ Build up a dictionary of Tid scans for an observing session
This processes all the files for an observing session to create a Python dictionary of Tid scans, indexed by scan number. Sometimes, scan numbers were re-used if scans had invalid data. In case a scan already exists in a dictionary, the one with the latest date/time is retained.
Notes
Some of the scans in the ASCII data files are incomplete. This can be detected by the number of numbers in the scan. SpectraData files have 64+320 numbers. DAVOS files have 65+16384 numbers. Anything else is invalid and rejected.
scantable() does not reject bad scans (e.g. all data values the same) but makes them invisible to get_scan(), summary() and getscannos(). The bad scans will show up, for example, in get_sourcename() as “” and get_direction() as (0.0,0.0). This is also causes scans to be lumped together in mini-scantables. This function rejects bad scans by checking that the data values are not all the same.
- :param pathstr::
Path to the original data files
- :param groupslist of lists of strings::
files grouped by DOY (observing session)
- :param group_indexint::
index of the group to process
- Returns
dictionary of Tid_scan instances:: indexed by scan number


A card is a flexible and extensible content container. It includes options for headers and footers, a wide variety of content, contextual background colors, and powerful display options. Cards require a small amount of markup and classes to provide you with as much control as possible. These classes and markup are flexible though and can typically be remixed and extended with ease.
For same heighted cards in a row, add .match-height
class to
row.
if your card doesn't have any flush content like images, feel free to put the .card-body
class on
the .card
element to consolidate your markup.
Card Structure

Special title treatment

With supporting text below as a natural lead-in to additional content.

Go somewhere

Vuexy

Content Types
Cards support a wide variety of content, including images, text, list groups, links, and more. Mix and match multiple content types to create the card you need.
Some card options with class name and details :
| Card Options | Class | Description |
|---|---|---|
| Card image top | .card-img-top |
Places an image to the top of the card. |
| Card Title | .card-title |
Card titles are used by adding this class to a <h*> tag. |
| Card Subtitle | .card-subtitle |
Subtitles are used by adding a .card-subtitle to an <h*> tag. If the .card-title and
the .card-subtitle items are placed in a .card-body item, the card title and
subtitle are aligned nicely. |
| Cards Header | .card-header |
To add header to the card. |
| Cards Footer | .card-footer |
To add footer to the card. |
| Gradient Cards | .bg-gradient-* |
To add gradient background to the card. |
| Outline variants | .border-* |
Replace the default modifier classes with this class to style just the border-color of a
card. |
| Groups | .card-group |
Use card groups to render cards as a single, attached element with equal width and height columns. |
| Decks | .card-deck-wrapper & .card-deck |
card decks require two wrapping elements: .card-deck-wrapper and a .card-deck.
We use table styles for the sizing and the gutters on .card-deck. The
.card-deck-wrapper is used to negative margin out the border-spacing on the
.card-deck . |
| Columns | .card-columns |
Cards can be organized into Masonry-like columns with just CSS by wrapping them in
.card-columns . Cards are ordered from top to bottom and left to right when wrapped in
.card-columns . |
Refer following links for detailed documentation, configuration options, methods and examples:
| Type | URL |
|---|---|
| Bootstrap Link | https://getbootstrap.com/docs/4.3/components/card/ |
| Card Template Page | https://pixinvent.com/demo/vuexy-html-bootstrap-admin-template/html/theme/card-basic.html |


Victor
is a student.
He drinks coffee.
AND codes stuff.
He drinks coffee.
AND codes stuff.
Hobby
enjoys reading,
code (with ☕),
and city photography.
code (with ☕),
and city photography.
Interest
in neural networks,
smart contracts, and
robotics.
smart contracts, and
robotics.
Code
❤ Python
Javascript
C C++
Go
Javascript
C C++
Go
Coded from scratch by Victor


A collider has a collision shape (box, sphere, capsule, ...) and is attached to a CollisionBody or RigidBody.
More...
#include <Collider.h>
|
|
class | OverlappingPair |
| |
|
class | CollisionBody |
| |
|
class | RigidBody |
| |
|
class | BroadPhaseAlgorithm |
| |
|
class | DynamicAABBTree |
| |
|
class | CollisionDetectionSystem |
| |
|
class | PhysicsWorld |
| |
|
class | GJKAlgorithm |
| |
|
class | ConvexMeshShape |
| |
|
class | CollisionShape |
| |
|
class | ContactManifoldSet |
| |
|
class | MiddlePhaseTriangleCallback |
| |
A collider has a collision shape (box, sphere, capsule, ...) and is attached to a CollisionBody or RigidBody.
A body can have multiple colliders. The collider also have a mass value and a Material with many physics parameters like friction or bounciness. When you create a body, you need to attach at least one collider to it if you want that body to be able to collide in the physics world.
◆ Collider()
Constructor.
- Parameters
-
| body | Pointer to the parent body |
| shape | Pointer to the collision shape |
| transform | Transformation from collision shape local-space to body local-space |
| mass | Mass of the collision shape (in kilograms) |
◆ getBody()
Return the parent body.
- Returns
- Pointer to the parent body
◆ getCollideWithMaskBits()
| unsigned short Collider::getCollideWithMaskBits |
( |
| ) |
const |
Return the collision bits mask.
- Returns
- The bits mask that specifies with which collision category this shape will collide
◆ getCollisionCategoryBits()
| unsigned short Collider::getCollisionCategoryBits |
( |
| ) |
const |
Return the collision category bits.
- Returns
- The collision category bits mask of the collider
◆ getCollisionShape() [1/2]
Return a pointer to the collision shape.
- Returns
- Pointer to the collision shape
◆ getCollisionShape() [2/2]
Return a const pointer to the collision shape.
- Returns
- Pointer to the collision shape
◆ getEntity()
| Entity reactphysics3d::Collider::getEntity |
( |
| ) |
const |
|
inline |
Return the corresponding entity of the collider.
- Returns
- The entity of the collider
◆ getIsTrigger()
| bool Collider::getIsTrigger |
( |
| ) |
const |
Return true if the collider is a trigger.
- Returns
- True if this collider is a trigger and false otherwise
◆ getLocalToBodyTransform()
| const Transform & Collider::getLocalToBodyTransform |
( |
| ) |
const |
Return the local to parent body transform.
- Returns
- The transformation that transforms the local-space of the collider to the local-space of the body
◆ getLocalToWorldTransform()
| const Transform Collider::getLocalToWorldTransform |
( |
| ) |
const |
Return the local to world transform.
- Returns
- The transformation that transforms the local-space of the collision shape to the world-space
◆ getMaterial()
| Material & reactphysics3d::Collider::getMaterial |
( |
| ) |
|
|
inline |
Return a reference to the material properties of the collider.
- Returns
- A reference to the material of the body
◆ getUserData()
| void * reactphysics3d::Collider::getUserData |
( |
| ) |
const |
|
inline |
Return a pointer to the user data attached to this body.
- Returns
- A pointer to the user data stored into the collider
◆ getWorldAABB()
| const AABB Collider::getWorldAABB |
( |
| ) |
const |
Return the AABB of the collider in world-space.
- Returns
- The AABB of the collider in world-space
◆ raycast()
Raycast method with feedback information.
- Parameters
-
| ray | Ray to use for the raycasting |
| [out] | raycastInfo | Result of the raycasting that is valid only if the methods returned true |
- Returns
- True if the ray hits the collision shape
◆ setCollideWithMaskBits()
| void Collider::setCollideWithMaskBits |
( |
unsigned short |
collideWithMaskBits | ) |
|
Set the collision bits mask.
- Parameters
-
| collideWithMaskBits | The bits mask that specifies with which collision category this shape will collide |
◆ setCollisionCategoryBits()
| void Collider::setCollisionCategoryBits |
( |
unsigned short |
collisionCategoryBits | ) |
|
Set the collision category bits.
- Parameters
-
| collisionCategoryBits | The collision category bits mask of the collider |
◆ setIsTrigger()
| void Collider::setIsTrigger |
( |
bool |
isTrigger | ) |
const |
Set whether the collider is a trigger.
- Parameters
-
| isTrigger | True if you want to set this collider as a trigger and false otherwise |
◆ setLocalToBodyTransform()
| void Collider::setLocalToBodyTransform |
( |
const Transform & |
transform | ) |
|
Set the local to parent body transform.
- Parameters
-
| transform | The transform from local-space of the collider into the local-space of the body |
◆ setMaterial()
| void Collider::setMaterial |
( |
const Material & |
material | ) |
|
Set a new material for this collider.
- Parameters
-
| material | The material you want to set to the body |
◆ setUserData()
| void reactphysics3d::Collider::setUserData |
( |
void * |
userData | ) |
|
|
inline |
Attach user data to this body.
- Parameters
-
| userData | Pointer to the user data you want to store within the collider |
◆ testAABBOverlap()
| bool reactphysics3d::Collider::testAABBOverlap |
( |
const AABB & |
worldAABB | ) |
const |
|
inline |
Test if the collider overlaps with a given AABB.
- Parameters
-
| worldAABB | The AABB (in world-space coordinates) that will be used to test overlap |
- Returns
- True if the given AABB overlaps with the AABB of the collision body
◆ testPointInside()
| bool Collider::testPointInside |
( |
const Vector3 & |
worldPoint | ) |
|
Return true if a point is inside the collision shape.
- Parameters
-
| worldPoint | Point to test in world-space coordinates |
- Returns
- True if the point is inside the collision shape
The documentation for this class was generated from the following files:
- /home/daniel/Development/Git/reactphysics3d/include/reactphysics3d/collision/Collider.h
- /home/daniel/Development/Git/reactphysics3d/src/collision/Collider.cpp


Trade talks in balance at Southeast Asian leaders summit
BANGKOK: Plans to finalise an Asia-wide trade deal at a summit in Bangkok this weekend were uncertain after new demands raised by India in the negotiations to create the world's largest trading bloc.
Southeast Asian leaders meeting in Thailand hope to make progress on the China-backed Regional Comprehensive Economic Partnership (RCEP) - which would comprise 16 countries that account for a third of global gross domestic product and nearly half the world's population.
Talks are expected to continue on the sidelines of the Association of Southeast Asian Nations (ASEAN) summit in Bangkok after a press conference was cancelled on Friday, raising questions whether ministers could reach agreement in their last formal negotiations ahead of a summit on the regional partnership on Monday.
Host Thailand has been pushing for a preliminary deal by the end of the year, keen to push ahead at a time when US-China tensions threaten to slow growth in the region.
A major sticking point has been demands from India, which is worried about a potential flood of Chinese imports.
"It's a fact India has put new demands which are difficult to meet," said a person with knowledge about New Delhi's negotiations.
READ: Southeast Asia leaders to push for progress on China-backed trade pact
READ: US-China tensions spur progress on giant Asia trade pact
Indian President Narendra Modi told the Bangkok Post in an interview he is committed to ongoing RCEP negotiations but added "opening the vast Indian market must be matched by openings in some areas where our businesses can also benefit."
Another person with knowledge of the talks said the Thai commerce minister had cancelled the press briefing in order to continue the marathon negotiations late into Friday night.
READ: PM Lee to attend ASEAN Summit in Bangkok
TRADE WAR
Any breakthrough on the Regional Comprehensive Economic Partnership would boost confidence in export-reliant Southeast Asia that has been weighed down by US-China trade war, with growth expected to slow to its lowest in five years.
"The finalisation of the RCEP negotiation has become a key test for ASEAN's capacity to deliver on its often-cited centrality," Marty Natalegawa, a former Indonesian foreign minister, told Reuters.
A draft final statement for the ASEAN summit seen by Reuters said the leaders would express "deep concern over the rising trade tensions and on-going protectionist and anti-globalisation sentiments".
Diplomats expected little discussion on perennial regional problems such as maritime disputes with China over the South China Sea and the plight of Rohingya refugees driven from Myanmar.
The United States, an important trade partner, downgraded its delegation compared to those in previous years.
Instead of President Donald Trump or Vice President Mike Pence, the United States will be represented by Commerce Secretary Wilbur Ross and White House national security adviser Robert O'Brien. China is sending its premier, Li Keqiang.


First Name
Last Name
Password
Email
Select a country...
Country
I do not agree with the
Terms and Conditions


Cryptic Musik
Underground Music
facebook
instagram
twitter
soundcloud
Home
About
Drum
Drum
Labels
Dubstep
Dubstep
Venue
House
house
Artist
Contact
Personal Information
Name
Email
Address
City
Country
- select
Afghanistan
Albania
Algeria
American Samoa
Andorra
Angola
Anguilla
Antigua & Barbuda
Argentina
Armenia
Aruba
Australia
Austria
Azerbaijan
Bahamas
Bahrain
Bangladesh
Barbados
Belarus
Belgium
Belize
Benin
Bermuda
Bhutan
Bolivia
Bonaire
Bosnia & Herzegovina
Botswana
Brazil
British Indian Ocean Ter
Brunei
Bulgaria
Burkina Faso
Burundi
Cambodia
Cameroon
Canada
Canary Islands
Cape Verde
Cayman Islands
Central African Republic
Chad
Channel Islands
Chile
China
Christmas Island
Cocos Island
Colombia
Comoros
Congo
Cook Islands
Costa Rica
Cote D'Ivoire
Croatia
Cuba
Curacao
Cyprus
Czech Republic
Denmark
Djibouti
Dominica
Dominican Republic
East Timor
Ecuador
Egypt
El Salvador
Equatorial Guinea
Eritrea
Estonia
Ethiopia
Falkland Islands
Faroe Islands
Fiji
Finland
France
French Guiana
French Polynesia
French Southern Ter
Gabon
Gambia
Georgia
Germany
Ghana
Gibraltar
Great Britain
Greece
Greenland
Grenada
Guadeloupe
Guam
Guatemala
Guinea
Guyana
Haiti
Hawaii
Honduras
Hong Kong
Hungary
Iceland
India
Indonesia
Iran
Iraq
Ireland
Isle of Man
Israel
Italy
Jamaica
Japan
Jordan
Kazakhstan
Kenya
Kiribati
Korea North
Korea South
Kuwait
Kyrgyzstan
Laos
Latvia
Lebanon
Lesotho
Liberia
Libya
Liechtenstein
Lithuania
Luxembourg
Macau
Macedonia
Madagascar
Malaysia
Malawi
Maldives
Mali
Malta
Marshall Islands
Martinique
Mauritania
Mauritius
Mayotte
Mexico
Midway Islands
Moldova
Monaco
Mongolia
Montserrat
Morocco
Mozambique
Myanmar
Nambia
Nauru
Nepal
Netherland Antilles
Netherlands (Holland, Europe)
Nevis
New Caledonia
New Zealand
Nicaragua
Niger
Nigeria
Niue
Norfolk Island
Norway
Oman
Pakistan
Palau Island
Palestine
Panama
Papua New Guinea
Paraguay
Peru
Philippines
Pitcairn Island
Poland
Portugal
Puerto Rico
Qatar
Republic of Montenegro
Republic of Serbia
Reunion
Romania
Russia
Rwanda
St Barthelemy
St Eustatius
St Helena
St Kitts-Nevis
St Lucia
St Maarten
St Pierre & Miquelon
St Vincent & Grenadines
Saipan
Samoa
Samoa American
San Marino
Sao Tome & Principe
Saudi Arabia
Senegal
Serbia
Seychelles
Sierra Leone
Singapore
Slovakia
Slovenia
Solomon Islands
Somalia
South Africa
Spain
Sri Lanka
Sudan
Suriname
Swaziland
Sweden
Switzerland
Syria
Tahiti
Taiwan
Tajikistan
Tanzania
Thailand
Togo
Tokelau
Tonga
Trinidad & Tobago
Tunisia
Turkey
Turkmenistan
Turks & Caicos Is
Tuvalu
Uganda
Ukraine
United Arab Emirates
United Kingdom
United States of America
Uruguay
Uzbekistan
Vanuatu
Vatican City State
Venezuela
Vietnam
Virgin Islands (Brit)
Virgin Islands (USA)
Wake Island
Wallis & Futana Is
Yemen
Zaire
Zambia
Zimbabwe
Areas of study
Program(s) of Interest
Animation
Fashion + Textile Design
Filmmaking
Fine Art + Visual Culture
Graphic Design
Interior Design
Photography
Product Design
If you would like information regarding our music events , please check the one(s) that apply to you:
Dubstep Events
Drum and Bass Events
House Events
None
Would you like to you like to be member?
yes
not at this time
Additional comments


[This paper is to be accompanied with the project that I have started working on as a Implementation project for Application Security course as a graduate student at NYU School of Engineering. The code can be found on my github page: https://github.com/sayaliupasani1/forum-server ]
Tornado is a web framework and an asynchronous networking library. I selected tornado as a framework instead of working with pythonâ€™s native base http server because python natively doesnâ€™t support asynchronous or concurrent I/O due to which python wonâ€™t be able to serve simultaneous requests. Though at this point there will not be many simultaneous connections, but I thought it is a good opportunity to make this forum scalable and expandable with improvements since I havenâ€™t seen any â€˜Forum-Serverâ€™ type implementation based on Tornado Framework
Note:
- The forum server is in its native/ basic development stages. It does not perform any sanity tests.
- It has many security loopholes and is definitely not ready for production stage.
This app uses sqlite3 and Python code currently does not support creating the database. This needs to be done manually before starting the forum-server app.
sqlite3 test.db
CREATE TABLE test.AUTH(
> ID INT PRIMARY KEY
> USERNAME TEXT
> PASSWORD TEXT
> EMAIL TEXT);
Note the security vulnerability here: I am storing the password in a plain text format. Also in the code, I am not hashing (+salting) or encrypting it.
INSERT INTO AUTH (ID, USERNAME, PASSWORD, EMAIL)
> VALUES (1, smu222, 'sayali'<EMAIL_ADDRESS>I am not creating a user registration page so letâ€™s create two users for our test purposes
CREATE TABLE test.FORUM(
> ID INT PRIMARY KEY,
> USERNAME TEXT,
> POST TEXT,
> POST_TYPE TEXT,
> TIME TEXT );
.quit
Currently I am not using post_type, but later when I develop this app further, it will basically show which is a parent post and which is a child post. Child post will bear the name or parent post in â€˜post_typeâ€™ and if the post is a parent post then it will hold a string â€˜parentâ€™.
' python forum_server.py --port=8888 '
'localhost:8888'
in your webbrowserAs soon as the python code is executed, the main function is called. The main function has some boiler plate to start the IO Loop of tornado framework. Python tornado has a options
class which creates a global namespace of any argument that is passed as command line. So that is where the custom port specified during run time is accepted by the IOLoop.
Once the loop begins, it creates an instance of Application
class and any communication on the port, creates a new instance and is handled by various callbacks.
Python tornado works on callbacks so that IO operations are performed in a non-blocking mode. This means that if there is any request on the port, the IOloop handles that and based on the type of request, it is sent to its callback method which does any computationally intensive work (such as dealing with db ) in the backend without blocking the main loop. Once the operation is completed, the IOloop pushes the result on the webpage. Thus, for example, when you browse to localhost:8888/login
the login
request will be handled by LoginHandler
method (in a callback mode). So for each page/ request a separate callback method is defined.
The interesting part in this application is that the person who has logged in should be able to post, view post and upload/ Download the files. This means that there needs to be a token/ cookie generated which is carried and verified everytime a user (authenticated/ non-authenticated) requests the pages/ methods.
To handle this, I have created a BaseHandler
class (which is then inherited by all the other classes). The only method that this class has is to get a secure cookie for that particular user. If the user is not authenticated, the get_secure_cookie
method will generate a cookie for such users.
The advantage is that for future, if there is a DoS attack or a bot trying to brute-force, then we can block the IP from which we are receiving such attacks
The authenticated user should be able to visit the forum page and upload/ download files page without having to authenticate everytime, for this we use Tornadoâ€™s built-in decorator tornado.web.authenticated
. This decorator keeps tab on the authenticated users and gives them access to the restricted pages.
Once the user passes the login id and password (which is currently accepted in plain-text format), the username and password is obtained from the html page using get_argument
method and is verified against the database for authentication. If the authentication fails, I keep a tab on number of times it failed (and later implement a way to block the IP or user or redirect them to a blank html page for a certain time). Once logged in, user is redirected to a home page which indexes the services the user can enjoy (Forum and File upload, download) and an option to Logout.
As the name suggests, this class is responsible for all the Forum related activities. As soon as the person requests this page, they are returned with all the posts in the database (without caring for post_type for now) and an option to write a new post (it creates a hyperlink but currently it doesnâ€™t redirect anywhere. After a complete implementation, it will redirect to a page with all its child posts in a communication like format). Once the user posts a new post, it is entered in the database along with the name of the user who posted the post and the time when it was posted. Once this process is done, user is redirected to the same webpage with updated database and output.
This class deals with handling the File Upload and Download
Currently the files uploaded by any user is available to all the users in the database. Soon this will be changed based on the preference of user to keep a file personal or public.
When the person requests this page, he/ she will be presented with an option to upload the file or download the files that exist on the server.
There might be a problem when the person uploads a file with the same name as the one that exists on the server. In this case the server by default will overwrite the previous file with the new one. To prevent this all the files are prefixed with random ASCII string.
When the person requests a file to be downloaded, the get
method of this class will grab the filename and prepare it to be pushed to the user as a file to be downloaded.
'def _execute(query)'
:
This function deals with executing any 'query'
that it receives as a sqlite3 query formatted string. If query is not successfully executed, it prints out the error on the console and on the web page.
As mentioned in the beginning of the documentation, this app has lots of security vulnerabilities right now and is not fit for deploying in production. Some of the vulnerabilities worth pointing out are:
As evident from the current version of the code, the app is very much prone to any type of sql injection. A very basic sql query in the post can expose the entire table(s).
Prevention: To prevent, the post that is posted will be sanitized before putting it in the database. The level of access to the database and its tables will be changed.
This version of forum-server does not implement any certificate and thus does not use any ssl methods.
Prevention: In later versions, the forum-server will use TLS over HTTP. but currently any sniffing in the network can reveal the passwords/ posts etc.
Currently the app does not scan the files for any malicious code. If a malicious code is uploaded to the server, it can not be stopped from execution (natively by the app). A simple malicious file with a bash script containing a command like ls
and some cat
commands can reveal a lot about the contents of webserver and about its structure.
Prevention: Some security mechanism to scan the files will be implemented. Some restrictions on the type of the files (based on extension) can also be implemented.
The passwords stored in the database is not encrypted/ hashed. The current implementation of authentication is impractical for production environment.
**Prevention:**Soon, this method will be replaced with a method that performs hash and salting before storing the password and authentication will be based on hashing and salting the user input and checking against the database
Currently the app has the database in the same location as the web serverâ€™s hosted files. This, again, is not an acceptable way of deploying the forum-server.
Prevention: Soon the database will be moved to a root folderâ€™s some path which is not accessible by the current user that started the forum-server. The database needs to have access restrictions as well as read/write privileged restriction.
There are few more vulnerabilities but it will be fixed before a RC version is released by me.
-Sayali Upasani


Our senior design project is underway right now. We are in the designing phase. We have not written any code yet for this project.
We are going to be working on a product called Cattle Krush. This is a product used in the agriculture industry to convey real-time data to cattle-owners about the best time to buy and sell cattle. The goal of this application is to alert cattle-owners when the best time to sell their cattle is so that they can make a profit.
Where do we come in? Well, this company has had a hard time getting an application on the App Store. Our job is to create a cross-platform (iOS, Android, and web) application that has the same functionality as the existing application.
At this point in the design, we believe that we will be using NativeScript as our cross-platform framework.
Oddly enough, I love refactoring and cleaning up code. There is great satisfaction in writing code that is easy to understand. I am looking forward to this project because we will be refactoring and cleaning up the current code. I have no previous experience in NativeScript, so I am looking forward to learning how to interact with this framework.
In this group project, we created a web application that did budget tracking and handling. You would have some initial income for your "budget term" (or pay period) and would create different categories that would split that money up. For example, you could have a food category, a clothes category, and a bills category. Expenses would be added to those categories. This application let you easily track how your money was spent. This same purpose could probably be acheived with an Excel-like application. However, this application has a much friendlier UI and is built to track budgets.
What makes this application distinct from a spreadsheet is that it can read receipts. You can upload an image of a receipt, and it will read the contents of the receipt, and build out an expense with the information it found about the various purchases listed on the receipt. This is nice because the user does not have to input every detail of a receipt. Instead, he or she can take a quick photo of their receipt and have the contents be added to their budget.
To extract the words from the receipt, we connected with a service called OCR.Space. This would search the image we supplied it for words and give those words back to us. This service helped us a lot with getting words from an image. It was also our limiting factor. This service would not always give us all of the words on the receipt (which means we can't list every puchased item), and it would also not correctly read words (lots of misspells). To get around the misspells, we used Bing Spell Check API to autocorrect the words that we received from the OCR (Optical Character Recognition) API.
This application was written in Java, running on Google App Engine.
Our demos for this application are split up into two parts:
In this group project, we created an application that would allow users create groups, enroll people in those groups, and keep track of members in the groups. The main twist of this project was that it had the feature of face recognition. You enrolled someone in your selected group by uploading a picture of them (along with some other basic information). Now the app can recognize a new picture of that person.
The primary function of this app is for educational purposes. The group owner can see all the people in his group, refresh his/her memory by seeing a picture of them, and can leave notes on that person.
A secondary function of this app would include attendance tracking. At the beginning of a semester, the instructor could pass around some type of tablet and have each student take a picture of themselves and upload it to the app. Then, each day, the instructor could pass around his tablet and have each student take a picture of themselves. If they were recognized, their "time last seen" would be updated to the current time.
This application was written in Java, built to run on Google App Engine. We used servlets for all of our request handling. Detecting faces in an image and recognizing them was handled by a service that we connected with via API called Kairos. This service alleviated a lot of the workload by doing all of the heavy lifting in detecting and recognizing faces.
Click here to see our demo video.
In this project, I was exploring the use of the JavaScript library, Node. Node is great for creating very fast, responsive web applications. One of the most common things to do in experimenting with Node is to create some sort of chat room. That is exactly what I did - I created a chat service. This service allows users to create public, private, and 1-1 chat rooms where they can chat with other friends or users of the application. A cool feature is that you can very quickly see when other users of the room are typing a message. Also, you can see what users are active in a given room.
In this project, I created an application that would
crawl
through wikipedia. The purpose of this crawling was to create a
graph
representation of the wiki pages. The application starts by
receiving a seed url (extention from the wikipedia base url). From
there, it begins crawling the seed url page, until the number of links
collected have reached some pre-determined limit. After receiving all
of these links (represented as vertices on the graph), the application
then began constructing edges between the vertices. The following is
the output graph when calling new WikiCrawler("/wiki/Computer_Science", 1000, "WikiCS.txt")
,
where "/wiki/Computer_Science" is the seed url, 1000 is the total number of
new vertices to fetch, and "WikiCS.txt" is the output file.
Each line is a vertex pair. That means that the item on the left side
of the column is connected to the item on the right side of the column.
Here is the output file:


--- layout: single title: Lessons for FedNow from India's UPI miracle category: fintech tags: excerpt: Identifies two main reasons for the success of India's UPI payment network for FedNow to consider in the design of their product. comments: true ---
In 2023, Federal Reserve of USA plans to launch 'FedNow' – a peer-to-peer payment network with instant settlement. This essay reviews the experience of India's Unified Payments Interface (UPI) – one the world's most successful publicly operated P2P instant-settlement payment networks – and identifies key lessons for FedNow.
Two features were central to UPI's revolutionary success:
The lessons for FedNow are straightforward:
The UPI, or Unified Payments Interface, is a semi-public payments protocol operated by an umbrella organization of India's banks; think Visa but for mobile payment and operated by a public-ish entity. UPI moves about 10 % of the total retail payment volumes in India — that's about 3.5Bn transactions per month. UPI apps, which include Google Pay, Amazon Pay, and Facebook's Whatsapp have more than 150 Mn active users between them.
Looking back, the rise of UPI in India has been nothing short of a miracle. Less than five years ago, in 2016, India retail customers made transfers worth $3.2 Trillion. Most of these funds were transferred using NEFT, which clocked around 100 Million transactions a month. Card network transactions were growing at 30% per year, and PayTM was fast emerging as the preferred mode of peer-to-peer payments. Fast-forward to the present, and UPI strides upon the Indian payments arena like a Colossus; IMPS, and the card networks lie vanquished. Private payment players like PayTM have mostly joined forces with UPI. Card networks actually lost share in transaction value in this intervening years. The UPI has truly become the one interface to rule all payments.
How did this happen? How did UPI – owned and operated by a quasi-government entity of all governance structures – come to dominate digital payments in India, building a customer base of several 100 millions of users, all within a span of 4 years? For context, it took Facebook and Twitter, with all their virality and global reach, the same time to reach 100 million users.
What explains this radical, miraculous success of UPI? While the fall in costs of data and smartphones that occurred after 2010 was a necessary condition for the emergence and growth of UPI, that alone cannot explain why UPI emerged as the preferred payment mode over other incumbents such as the Central Bank operated IMPS. Even though may rightly point to the demonetization of Indian currency in 2016 as a cruel catalyst for the initial adoption of UPI, that alone cannot explain UPI's sustained growth since then, or the decline of Paytm — the dominant payment incumbent at the time of demonetization with a wider network of merchants.
I propose that UPI's success boils down to two design decisions at the heart of the protocol's design:
At the bare-metal level, UPI's underlying code was designed to minimize the integration effort it took for banks to join the network. Integration efforts are one of the biggest blockers in the path of substantive improvements in Indian banking. For instance, in 2019, when the Indian government merged six state-owned banks, the choice of which banks to merge with which other boiled down to the technological compatibility of their respective backend systems.1 To avoid the same fate, the UPI team needed to make it easy for banks to plug into the network they had created, irrespective of their backend technology. Their solution was to develop a ready-made software module to handle most of the core administrative tasks involved in processing transactions, along with minimizing and standardizing the points of contact between this module and the rest of the bank's core-banking systems.
Consider the life cycle of a customer on a payments network. Such a customer would first need to register herself and link her registered identifiers like a unique handle and a look-up to an underlying account, that customer would also need to set some kind of authentication mechanism for transactions, and of course, she should be able to perform debit transactions, receive credit transactions, and also perform ancillary services such as fetching the balance of her linked account and a list of past transactions. All of these routine administrative tasks and operations could be standardized and externalized into a single module, instead of asking the banks to develop their custom implementations. Even if banks could reliably implement those tasks and operations, idiosyncratic variations between the implementations of each bank lead to conflicts and roadblocks in the future developments of UPI.
The UPI team's solution leveraged a concept known as 'containerization', where the code and the surrounding environment required for an application is contained within an 'installer'. Think of a container as an installer file for a PC game, but, instead of just installing the game, the installer first spins up a virtual machine with the appropriate operating system and other dependencies installed and then installs the game/application. This container installed the 'UPI switch' as the team described. It was the 'UPI switch' that was responsible for handling most of the heavy lifting involved during various stages of the customer life-cycle. the UPI team created the UPI network around a UPI switch, a containerized application (think of this as an installer, like a .exe or a .dmg file) which handles all of the heavy lifting involved in the customer life-cycle, reducing the interfaces with bank's IT systems. In fact, under this approach, the bank IT system only needed to provide interfaces to debit a customer's account and to check the balance in the customer's account. This central UPI switch was designed as a containerized application deployed on-prem on the bank's compute infra.
The UPI switch then operated as a collection of micro-services handling administrative tasks such as registering users and their PIN. Transaction authentication happened via a PIN input by the customer on their device. Once again the UPI Switch micro-service performed the authentication of the input PIN without the bank CBS having to step in. Such a micro-service reduced the integration required between UPI and the specific CBS systems of banks, allowing the entire UPI network to function with just three end-points connected to bank CBSes – one to look-up customers, one to check the balance of a given account, and another to debit an account. The IT vendors of banks were free to implement the back-end for these end-points in whatever manner worked best for them.
The net effect of all this to solve one part of the 'cold-start' problem involved in starting up a two-sided network from scratch. With bank onboarding a solved problem, the UPI team could now focus on attracting customers.
While a smoother onboarding of banks was one part of the 'cold-start' puzzle, UPI still had to solve the problem of acquiring customers. And here, the UPI team correctly perceived that acquiring customers was not a task to be left to the Government, Government-owned banks, or even incumbent private banks. Instead they designed the UPI APIs and SDKs such that third party applications could enjoy authenticated 'Write' access to the underlying accounts of the customers maintained with incumbent banks.
The UPI team's decision would later pay the way for the arrival of giants such as Google Pay and Amazon Pay, who spent considerable marketing budgets acquiring customers and merchants. The market share of various payment apps serves as a progress card for the decision to unbundle 'servicing' from account ownership. As the figure below shows, the UPI landscape in India is entirely dominated by the top-3 apps enjoying a cumulative ~85% share of transactions and value. The share of transactions processed by all 150 banks on the UPI network barely exceeds 3%. Despite the head start banks enjoyed in onboarding customers through their mobile banking applications, the largest UPI-based payment apps in India are private fintech players such as Google Pay, PhonePe and Paytm. Rather characteristically, the banks have been beaten hands-down in the game of onboarding and delighting customers, a fate the UPI team, presumably could've claimed to see from miles away.
Funnily enough, surprisingly few analysts have identified this unbundling as a major factor behind the success and growth of UPI.2 Instead, a lot of attention was devoted to the falling cost of data and cheaper devices as the reasons for UPI's success. All of those factors could also have allowed PayTM's private network to monopolize India's mobile payments, but instead it is UPI that emerged triumphant, with PayTM eventually joining the network.
The 'first-class' citizenship offered unregulated private fintechs made it possible for the likes of Google Pay to enable a customer to onboard themselves and to transact using their account entirely from within Google Pay, without any involvement of the underlying bank's systems or interfaces; the UPI stack offered a self-contained transactions suite. Similar to local loop unbundling in public utilities like power, distribution was separated from 'generation'. Unlike in USA, where Google Pay and Apple Pay achieved such disintermediation by leveraging NFC to emulate debit/credit cards within customers' devices, supporting customers on UPI required no such workarounds. Customer facing applications were first class citizens of the UPI ecosystem, by virtue of the separation of concerns between customer on-boarding and customer account operation.
In the final analysis, this direct access to 'Write' APIs on top of the customer's bank accounts is what helped UPI beat PayTM. PayTM, initially designed as a wallet, continued to require users to first make a deposit into their PayTM wallet/ account, and then perform transactions from that wallet/account. UPI on the other hand removed the need for customers to 'load an intermediary wallet/ account' before performing a transaction. Users could now move money on the fly via UPI. 'Write' APIs for user's bank accounts continues to be elusive in India's highly conservative and paternalistic banking ecosystem, a fact highlighted in a previous post on CBDCs in India.
The regulatory and UX arbitrage in allowing customer facing applications to distribute financial products is a gift that keeps on giving. The march of disintermediation beats on inexorably, spreading from relatively peripheral P2P transactions to online and ecommerce transactions, to investments now, and soon (potentially) to credit. Consider the case of Fixed Deposits in India, and the stunning success of Equitas Bank's launch of their FD product on Google Pay3. All this in a product without the network effects of a payment protocol/ network. Nothing can stop the juggernaut of a well-designed product combined with word-class distribution.
As the sections above illustrate, UPI had all the right ingredients to create magic. However, it still took the entry of a behemoth, in the form of Google Pay, to evangelize and market the protocol. Without Google's aggressive cashback offers (users could receive between INR 20-100 for each transaction they performed) and extensive merchant acquisition, it's hard to see UPI reach its current levels of usage. To be clear, UPI did create its own luck. The massive regulatory and UX arbitrage created by allowing unregulated applications to service customer bank accounts is what opened the doors for Google Pay; without that crucial technical and governance decision, Google would've probably balked at applying for some curmudgeonly license, and the UPI we see today would still be an underdog if not an also-ran.
Google Pay's scorched earth marketing and customer acquisition campaigns created the critical mass of customers UPI needed for 'lift-off'. Once this critical mass was reached, the network effects inherent meant that not too long after, merchants would also start joining the UPI network. The transition from offline merchant collections to online collections was even smoother, thanks to the robust, extensible API provided by UPI's API specifications. As to why Google decided to bet big on a nascent payment protocol in a relatively peripheral market, we can only speculate. Perhaps, having an Indian CEO may have helped.
So, what should we and FedNow take away from UPI's success story.
The United States' mobile payments market appears similar to India's payments market before UPI. We see the same cast of a few rickety, unpopular payments rails that stifle mobile payments, a few closed-loop wallets that charge exorbitant amounts to withdraw your own funds, and a growing reliance on card networks. If FedNow learns its lessons and plays its card rights, the biggest payments market in the world will experience nothing short of a revolution.


×
Home
Logout
Dashboard
Users
Organisations
Facilities
Service Types
Services
Locations
Occupations
Dashboard Settings
Services
Name
Type
Description
Update
Cancel


We’re a results-driven digital marketing agency located in London (UK) and serving clients nationally. Driven by the success of our clients, we take great pride in the online strategies we implement to drive website traffic, convert visitors into leads and improve sales.
We’ll you grow your bottom line by leveraging retargeting strategies, search intent, and automated sales funnels. By using a combination of email marketing, Facebook and Google search and retargeting ads, and highly converting landing pages, we’re able to dramatically increase your return on investment.
Whether you’re a B2B company looking to capture high-quality leads online, or an eCommerce business looking to grow your sales online, our team of specialists will help you reach your target market and convert them into new customers. While automated sales funnels, Facebook/Instagram advertising, and Google Ads are our primary focus, we have a diversified team of digital marketing specialists to help grow your brand and business.
Click here to meet our founder, Michael Ohioze.
Sure, you want a presence on social media, expanded market awareness and hopefully engagement from fans and followers. But what will drive your revenue is converting that awareness and engagement into real visitors to your site who inquire to learn more about your company and product/service and who eventually turn into your customer.
It’s new revenue as a result of doing business with us – that’s all that matters to our team. It’s also what matters to our clients.
To deliver results based online marketing services to clients who don’t have the people, resources, time or expertise to get a measurable return on inbound marketing.


--- layout: post title: "No Title" ---
Earth Hour exists so that people who do nothing can feel like they’re doing something. Drive home from work in your 4X4, turn on the air conditioning, watch programs on your massive TV, leave it on while you have a 30 minute shower, turn off your lights for an hour, feel good about the real difference you’re making to the environment.
An advertisement in the local paper read: “Join the Redland City Council as it turns off all non-essential lighting for Earth Hour”. How about turning off non-essential lighting all the time?


Hive Docs
The Launch
NOTE: The Hive blockchain forked away from Steem at 10am EST, March 20th, 2020 (Hive block 41818752).
The buzz is real! After weeks of hard teamwork, we’re announcing the launch of the new Hive blockchain.
This is an exciting time, and an opportunity to channel the love and power of a resilient and tenacious community into collaborative development for the future of social blockchain.
Hive is a passionate effort, created by a large group of Steem community members who have long looked to move towards true decentralization and to help develop the code base. The years of distribution issues and reliance on a central entity for code and infrastructure has been at the heart of a revolution of sorts, and the new Hive blockchain is the culmination of stepping up to meet the challenge of returning to shared values of protecting and celebrating the vibrant community that has grown around our ecosystem.
Check out the FAQ below for info on the launch of Hive.
What is Hive and why was it created?
Hive is a DPOS governance blockchain created by implementing a hard fork of existing Steem code.
The intention of this community-driven fork is to support and build on the strong Steem community values that have made our ecosystem so diverse and exciting. This new direction steps away from the burden of the Steemit Inc. ninja-mined stake, which has impacted the long term ability to work towards further development and decentralization for years.
Hive has begun with a talented and committed team of community developers who are already paving the way to implement much awaited improvements and robust new developments to the blockchain. It is exciting to see the community – from devs and business owners to passionate end users – stepping forward to embrace and contribute to the potential of Hive. This renewed spirit, combined with a renewed codebase and a focus on working more closely with the entire ecosystem, is key to the success and possibilities for the future of social blockchain.
What is the difference between Hive and Steem?
Hive is a fork of the Steem blockchain and runs completely independently from the existing chain. All valid accounts on the Steem blockchain will receive an airdrop on Hive. (more details below)
While the Hive chain is a fork of the Steem code, the intention is to take responsibility to build something even better. The initial Hive launch will be a direct copy of existing blockchain with a few small upgrades, which will allow us to get back to community discussion on the direction for future development, needed changes, and most wanted chain-level features.
The spirit of Steem and the goal of decentralization has always been to move away from a single point of authority, and to capitalize on and encourage the potential that has gathered in our community. Hive is drawing on the huge range of talent in our ecosystem to accelerate development, improve communication, and return to a focus on ease of use, onboarding, and marketing. The desire to move towards better decentralization and to connect people via blockchain has never been lost, and it’s what makes Hive so needed now.
What happens when Hive launches?
When The Hive blockchain launches, existing Steem accounts will appear on the Hive Network as well. You will have two accounts: the current one on the Steem, and a new Hive account, which will be pre-populated with all of your current Steem content and information.
The history of these two accounts will be the same, but from the snapshot point onward, the accounts will be independent from one another. Actions you take on one network will not be reflected on the other. This means that future content and transactions will belong to whichever account you use.
If you post on Hive, it will not show up on Steem, and vice versa. The two chains will be completely independent of one another after launch.
When will Hive launch?
The Hive blockchain launch will be at 10am EST/14:00 UTC, Friday, March 20th. (countdown at https://hive.io/) All of the magic will happen this week! The snapshot and airdrop will take place back to back at the time of launch.
Where can I find Hive’s code?
Here is the public open source repo for Hive:
https://github.com/openhive-network/hive/releases
As a STEEM holder, what do I get in the Hive airdrop?
All valid STEEM stakeholders will receive a perfectly mirrored balance of their current STEEM holdings in the new HIVE coin. This will include matching amounts of current liquid STEEM, Steem Power, and SBD. All other account state data, such as claimed accounts, delegations, etc. will be mirrored onto Hive.
For example: if your Steem account has 10 STEEM, 5 SBD, and 1000 SP, your new Hive account will have 10 HIVE, 5 HBD, and 1000 HP.
You will not need to claim anything. Simply log in with your existing Steem account details and you will have your new HIVE coins in your wallet and be able to start using the blockchain.
The Hive airdrop will only be performed on the current version of the Steem blockchain (as of the date of this post). Any “emergency hardforks” performed prior to the airdrop will not be eligible. Further, any exchange that participates in such a hardfork prior to the airdrop date will null and void the ability to participate in the airdrop for its off-chain balance holding customers.
How do I access my Hive account to post content and send Hive coins?
You can access your Hive account by simply logging in on the Hive Network using your existing Steem account keys. The first frontend available will be https://hive.blog. This is currently pointed at the Steem blockchain, but will be switched to Hive at launch time. Other popular interfaces are completing the switch over to Hive or finishing new products, and will be announcing when they are ready to use!
Who is behind the development of Hive?
There are currently over 30 experienced developers contributing to the new ecosystem, alongside many committed community members working on multiple aspects of Hive. These individuals may announce their participation through their own accounts in the future. This a true community effort, and therefore is open to all. Hive will remain open source, and open to everyone who wants to contribute to the future development of the blockchain. Testnet will be available after this post is published, so feel free to comment here if you would like to access and we’ll reach out. The full codebase will move to a public repo on Thursday, March 19th, prior to launch. Updates will be made to this post and via this account.
What improvements have been added?
The most important improvements and decisions will be made after initial launch with a chance for proper feedback from the community. To successfully launch, there are some aspects that needed to be addressed immediately, including prevention of exchanges from participating in governance attacks (as we witnessed on the Steem Blockchain).
To prevent governance (or funding) attacks, a 30 day delay has been added on crediting vests towards witness and SPS votes. Further governance changes will need to be developed alongside the community.
This delay means that after an account “powers up” or stakes funds, there will be a 30 day delay before those vests can be used towards voting on governance (witnesses) or through voting in the SPS. For all other actions, there is no delay and vests are immediately available.
This is an initial way for us to mitigate this risk while continuing to improve the system as a whole, and without deciding on governance changes before returning to collection of wider community input.
Will all Steem accounts be included in the HIVE airdrop?
The goal of Hive is to continue moving towards true decentralization, and therefore the launch airdrop will include all accounts who have showcased these same values and shared goals.
The only accounts who will not be included in the initial airdrop are those containing the Steemit Inc ninja-mined stake, and those who actively contributed to (and publicly declared support for) the centralization of the Steem Blockchain.
These accounts can still choose to take part in the new chain and their accounts will exist, but they will not be included in the intial airdrop.
Important notes for cryptocurrency exchanges that list STEEM
Do you plan to support the Hive airdrop by taking a snapshot of your customer’s Steem holdings at the time of the airdrop and credit them with a similar amount of Hive (Yes/No)?
YES) If you DO want to participate in the airdrop, please notify the Hive team that your exchange will distribute the airdrop on a pro-rata basis to your Steem customers (no fixed timeline for distribution is required), and the Hive account that corresponds to your Steem account will receive the airdrop at the time of the launch of Hive.
NO) If you DO NOT want to participate in the airdrop, please send out a notification to your Steem-holding users to forewarn them that you will not be participating, so that they can temporarily withdraw their Steem from your exchange before the airdrop snapshot date, if they wish to participate in the Hive airdrop.
If at all possible, please let us know by Thursday, March 19 if you will or will not be participating in the airdrop.
You can notify us by leaving a message on this post using your official Steem account, or you can contact one of our exchange liaisons:
- Gandalf (located in Europe) telegram: @Gandalf_the_Grey email<EMAIL_ADDRESS>- David Jefferys (located in US) telegram: @djefferys
Direct follow-ups will be made, but if we do not receive an affirmative response by days end Thursday, March 19th, we will assume that your exchange doesn’t wish to participate in the airdrop for holding customer balances.
We’re looking forward to the launch of Hive!
There’s a lot to come during this extremely busy week, and this post and account will be updated to reflect new information as it becomes available.


Baker
North
Seibel
Sid Rich
South
West
Servery
Vegas
Food 1
Food 2
Food 3
Food 4
Food 5
Food 6
Food 7


Aspiring Fullstack Developer
Need help with your great apps ideas! I can help. Contact me and let's get it rolling.


A CPU (or Central Processing Unit) carries out instructions given to it. A CPU is comprised of transistors that can be combined to build logic gates, which in turn build the circuitry inside a processor.
The CPU carries out instructions in a series of Fetch, Decode and Execute cycles, where data is retrieved, decoded for instructions and then executed by the CPU.
With increasing speeds, smartphones today can have faster processors than those of desktop computers just ten years ago. This is down to Moore's law.
Clock Speed
Processors work at incredibly high speeds, performing cycles of Fetch, Decode and Execute over a billion times in less than a second.
| Unit | Pulses per Second |
|---|---|
| 1 Hertz | 1 |
| 1 Kilohertz | 1000 |
| 1 Megahertz | 1000000 |
| 1 Gigahertz |<PHONE_NUMBER> |
Gordon Moore, founder of Intel®, predicted in 1965 that the number of transistors would double approximately every two years. This trend is described as Moore’s Law. Doubling the number os transistors (into the same space) increases the speed of the processor.
Although this trend is beginning to show an end as physical limitations begin to become more apparent, there is still evidence of the effects of Moore’s Law as processor speed continues to grow exponentially.
What is a register?
A register is a memory location within the CPU.
The registers themselves are extremely fast and can be used without causing a bottleneck (the slowest part of the system that limits the speed as a whole).
Program Counter:
Keeps track of the memory location of the line of machine code being executed. It gets incremented to point to the next instruction, with each cycle of the fetch-decode-execute cycle allowing the program to be executed in sequence one by one.
The program counter is also affected by instructions which alter the flow of control - for example LMC has BRZ, BRP and BRA.
Memory Data Register (MDR):
Stores the data that has been fetched from or stored in memory.
Memory Address Register (MAR):
Stores the address of the data or instructions that are to be fetched from or sent to.
Current Instruction Register (CIR):
Stores the most recently fetched instructions, waiting to be decoded and executed.
Accumulator (ACC):
Stores the results of calculations made by the ALU.
General Purpose Registers:
Processors can also have general purpose registers, which can temporarily store data rather than sending data to and from the comparatively much slower memory.
Buses:
Buses are communications channels through which data can be sent around the computer. There are three buses inside the computer we need to consider:
Data Bus - carries data between the processor and memory.
Address Bus - carries the address of the memory location being read from or written to.
Control Bus - sends control signals from the control unit.
Arithmetic Logic Unit (ALU):
Carries out calculations and logical decisions. Results are stored in the accumulator.
Control Unit (CU):
Sends out signals to coordinate how the processor works. It controls the how data moves around parts of the CPU and how it moves between the CPU and memory. Instructions are decoded in the control unit.
Cache Memory
RAM is faster when compared to the speed of secondary storage, however it is still slower in comparison the CPU - making RAM a bottleneck in the speed at which processor can operate.
To improve upon this, a small amount of fast memory is built into the processor itself reducing the distance data has to travel - this is Cache Memory. By anticipating regularly used data and moving them to Cache, the overall speed of the processor can be improved. As well as being expensive however, larger sizes of cache work slower and therefore often modern computers have multiple levels of cache.
Multiple Cores:
A CPU can have multiple cores, the most common being “dual core” and “quad core” processors. Each core is a distinct processing unit on the CPU, as well as having its own cache the cores also share a higher-level cache that works directly with RAM.
When multitasking, each core can work on different applications. Through parallel processing it is also possible for multiple cores to work on the same task. Four cores does not mean the processor will work four times as fast.
Pipelining:
Pipelining is a method used within processors, with one instruction being executed, the next instruction being decoded all while the the one after being fetched from memory.
Sometimes it is not able to be accurate when predicting what instruction needs to be fetched and decoded next. For example we might need to branch to another instruction. This is called flushing the pipeline.
The more we have to the flush the pipeline, the less benefit pipelining gives us.
Imagine a manual car wash: one person fetches the water, another cleans the car and finally someone rinses the car off.
| Fetch Water | Clean Car | Rinse Off | |
|---|---|---|---|
| Step One | Car One | ||
| Step Two | Car Two | Car One | |
| Step Three | Car Three | Car Two | Car One |
| Step Four | Car Four | Car Three | Car Two |
Graphics Processing Unit (GPU):
A GPU is a processing unit specifically designed to perform calculations associated with graphics.
They have instruction sets specifically designed for the sorts of calculations required in graphics processing.
Often when rendering graphics, the same process needs to be performed for multiple points on the screen. To speed this up, a GPU has the ability to process these data in parallel; what is referred to as single instruction multiple data (SIMD).
Uses of GPUs include: modelling physical systems, audio processing, breaking passwords and machine learning.
Input Devices allow data to be entered into a computer.
Examples include keyboards, mice, microphones, scanners and joysticks.
Output Devices allow information to be retrieved from a computer.
Examples include printers, speakers, monitors and actuators (devices that cause movement).
Storage Devices
There are 3 types of secondary storage possible for a computer. This is Magnetic, Optical, and Flash (otherwise known as Solid State Memory). It is important to note that secondary storage is not required for a computer to operate, rather it is an extension.
Magnetic storage uses a magnetisable material. Patterns of magnetisation are used to represent binary patterns. These types of storage are found in hard disk drives nad magnetic tape. Magnetic storage is high capactiy at low cost. Despite this there is the issue of reslience as magnetic storage can be damaged if moved when reading or writing.
Optical storage work by having small indents across a surface representing either a 1 or 0. This storage is typically found with CDs, DVDs and Blu-ray discs. This type of media is cheap to produce and therefore distribute and are fairly resilient.


You've reached the OAuth 2 authorization server for De Bolk.
Read the excellent introduction to OAuth2 by DigitalOcean to understand the terminology and process involved in an OAuth 2 authorization process.
The process is best described using a flow-chart:
Log in to PHPMyAdmin on prism. Register your client in the database named "login", table "oauth_clients". You'll need to enter a client_id, client_secret and redirect_uri.
Direct the user in a HTML-compatible browser to
https://auth.debolk.nl/authenticate?response_type=code&client_id=example&redirect_uri=http://example.org&state=123456
with the details of your application added. The state parameter must be randomly generated. The authorization server will ask the client to log in and confirm that he/she will allow your application access to his/her account.
If the user agrees, the authorization server will redirect the browser back to your application (redirect_uri) with a "code" and a "state" parameter:
http://example.org/?code=2a134b08d15a90e5901f24a98a129&state=123456
The code parameter is your authorization token. It is valid for only a few seconds. You must trade it in for an access token in step 2.
If the user disapproves, the authorization server will redirect back to your application too, but with a "error" and "error_description" parameter explaining the cause, for example: http://example.org?error=access_denied&error_description=The+user+denied+access+to+your+application&state=1
.
You must validate that the returned state parameter is identical to your original parameter. If it is not, warn your user and restart the process, otherwise you are at risk of CSRF-attacks (and the authorization token you received probably won't work anyway).
If the user approved your application to access his/her account, you must send a POST-request to the authorization server at the address:
<EMAIL_ADDRESS>(replacing client_id and client_secret with your values)
with the following data encoded as JSON. Be sure to add a correct Content-type: application/json
header.
{ "grant_type":"authorization_code", "redirect_uri":"http://example.org/", "code":"example-authorization-token" }
Alternatively, you may also use the endpoint https://login.i.bolkhuis.nl/token
and supply all parameters in valid JSON:
{
"grant_type":"authorization_code",
"redirect_uri":"http://example.org/",
"code":"example-authorization-token",
"client_id": "",
"client_secret": ""
}
The response of the request will contain an access token which you can use to access resources on behalf of the user. The access token looks like the following:
{ "access_token": "fb028dac33e168c60d6558a610cbbaf289f02871", "expires_in": 3600, "token_type": "bearer", "scope": null, "refresh_token": "cfa09ad5ab1c9418c6541c7726360d7b06c47e9b" }
If your request fails for some reason, the server will return an error and an error description, like this:
{ "error": "invalid_request", "error_description": "The grant type was not specified in the request" }
You do this by calling the authorization server at the following url:
https://login.i.bolkhuis.nl/resource/?access_token=example
If valid, the authorization server will return the full access token, the ID of the user (which you can use to look up the user details in blip and operculum) and the expiry time of the access token (ISO 8601-formatted), which looks like this:
{"access_token":"example","user_id":"jakob","expires":"2014-09-29T22:37:09+00:00"}
If invalid, you should return a 403 Unauthorized header and pass along any error codes from the authorization server to the client in the body. Otherwise you may grant access to the user.
Please do not refresh already fresh tokens to reduce server load. Calculate and store the expected expiry time of your access token, minus 50 seconds or so to accomodate for clock drift, and refresh the token only when needed.
Using your refresh token, issue a JSON-encoded HTTP request to:
https://auth.debolk.nl/token/
using the payload:
{
"grant_type": "refresh_token",
"refresh_token": "",
"client_id": "",
"client_secret": ""
}
If succesful, this will return a full new access token (see above for specification) and a full new refresh token. You can and should instantly overwrite your entire currently stored token with the new data. Be sure to update the expected expiry time of your token, if needed.
Using your access token, you may make requests to a resource server on behalf of the user. How to send the access token is dependent on the resource server, but the consensus is to simply append it to an URL, for example:
http://musicbrainz.i.bolkhuis.nl/player/mjs/mp3soos?access_token=example
The server will verify that your access token is valid and (if it is) execute your request.
The process is best described using a flow-chart:
This is dependent on your server, though the accepted default is to simply append it to the URL:
http://server.nl/resource/?access_token=TOKEN
As a resource server, you need to validate access tokens sent to you by clients. You do this by calling the authorization server at the following url:
https://login.i.bolkhuis.nl/resource/?access_token=example
If valid, the authorization server will return the full access token, the ID of the user (which you can use to look up the user details in blip and operculum) and the expiry time of the access token (ISO 8601-formatted), which looks like this:
{"access_token":"example","user_id":"jakob","expires":"2014-09-29T22:37:09+00:00"}
If invalid, you should return a 403 Unauthorized header and pass along any error codes from the authorization server to the client in the body. Otherwise you may grant access to the user.
If the access token checks out, you may grant access on behalf of the specified user. Alternatively, you may check if the user has a specific authorization level. Five authorization levels currently exist:
Additionally, there is a group in LDAP named 'oauth-test' which is normally empty. Adding a user to this group will grant all authorization levels, allowing for testing oauth security. Do not add users to this group permanently.
You can check whether the current user can access the authorization level "ictcom" for example by requesting the URL:
https://login.i.bolkhuis.nl/ictcom/?access_token=example-access-token
and checking whether the HTTP status code of the response is 200 OK.
It is possible for clients to request an access token based solely on their own existence, not an actual user account. These tokens, while valid, have the lowest possible privileges and are only used in very specific scenarios. A proper example is the door lock: the door reads a pass ID through NFC and sends it to the passmanagement API. The Passmanagement API than answers whether the door should grant access. This API call is secured over OAuth, but the door has no user input apart from the pass and therefore cannot allow users to login. The door lock uses a client credentials flow to request an access token, and signs its request to the API with this token. The client credentials grant is in accordance with the OAuth 2 RFC: https://tools.ietf.org/html/rfc6749#section-4.4.
To execute a client credentials grant, send a POST request to
https://auth.debolk.nl/token
with the correct Content-Type: application/json
header and the following body:
{
"grant_type": "client_credentials",
"client_id": "",
"client_secret": ""
}
If approved, the authorization server will return a valid access token:
{
"access_token":"",
"expires_in":3600,
"token_type":"Bearer",
"scope":null
}


Name: Training
Status: Obsolete
General: After analysing the parameters, the system switches to read test input.


--- layout: post_notitle title: SRCCON Session Proposals logo: srccon_logo.png ---
The list of accepted sessions is posted. We are grateful to have received so many excellent proposals, and were glad to be able to merge several similar sessions to get in as many distinct ideas as possible while maintaining topical balance. We enthusiastically encourage everyone who pitched to attend sessions that relate to their proposals and add their perspectives to the discussion.


{% extends 'layout-bsa.html' %} {% block pageTitle %} Is your household income £15,276 or less? - LIS training - NHSBSA {% endblock %} {% block outerContent %} {% endblock %} {% block content %}
This is the income that is used to work out your Tax Credit payments.
You can find this on your current tax credit award notice or contact the tax credits helpline (opens in a new tab).


Judith M Cale
Republican
I am a retired high school teacher. This year I have worked part time for Arapahoe County as an election judge.
See attached curriculum vitae.
80015
I have written to and sent emails to state and federal legislators on issues that are important to me. This year, I have been an election judge for three state and federal elections in Arapahoe County.
I have belonged to the following professional and volunteer organizations: The Colorado Congress of Foreign Language Teachers, The Southwest Conference on Language Teaching, Colorado Master Gardener for Arapahoe County, Child Rescue Orphanage Board Member, Colorado Baptist Disaster Relief, The Gideons International Auxiliary Denver Metro Regional Director, Community of Grace Women's Ministry Leader
As a past president of the Colorado Congress of Foreign Language Teachers, I have planned, organized, and carried out multi-day state conferences with an attendance of about 600 world language educators which included workshops, keynote speakers, and sessions led by national and state presenters. I have advocated for world language education with state and national legislators or their aides several times. At the Arapahoe County Fair, I have represented the Colorado Master Gardener program and have been a presenter and newsletter writer of several aspects of gardening. Also, as Women's Ministry Leader of my church, I have planned, organized and carried out women's events on a variety of topics, occasionally with other churches.
This is of utmost importance and will affect Colorado for many years to come. I believe I can listen to all sides, consider all aspects of the dialogue, be fair and non-partisan, and make wise decisions.
First, I think listening to everyone's ideas and viewpoints while taking notes is important. Next, determine which ideas are similar and which thoughts have no agreement. Then work on wording of ideas to create consensus. As a retired high school teacher with three decades of experience, I had to be impartial when students were arguing, had disagreements, and then come to a resolution that all sides could live with. Also, I have led socratic seminars with students and adults to ensure that everyone has a voice and could state their opinions.
Again, I believe it is important for everyone to state their opinions and give reasons why they think they are correct. Then, are the reasons factual or emotional? Where are the opinions coming from? Is the source reliable, from a social media platform, or a third party opinion? Is the source recent or from 10-15 years ago? All these are pertinent questions to ask when resolving a problem. From this information and probably others, I then make my decision.
female


The Groups, Memberships, and Master View
The Groups, Memberships, and Master View windows are exactly the same as that of Users except for two places:
- the 'target' variable (to define a unique window target)
- the 'table' variable (to specify which table definition file to load)
The differences are highlighted in the right.
Steps:
- Copy or enter the text from the right into the file


{% extends 'base.html' %} {% block content %} {% if errors %} {% for error in errors %} {% if error %}
ATTENTION: After clicking "SUBMIT" please wait until the page redirects. This may take a bit of time.


Balu Kaimu:
Armor yourself in silver armor and grasp Gazkh!
(Bluish light plays across the head of the ax, clearly outlining both it and the seal emblem.)
Seal, tell me truly today if our Elrokian warriors will be victorious over the vicious creature, Sailren!
Mother Shilen!
Be with us so that we may rightly execute the sacred duty you entrusted to us.
The dawn of battle already makes the eastern sky blush, and the warriors' voices are raised in song as they prepare to go forth.
As the letters on the stone pillar are again scrambled and reorganized, you hear a clear and somber melody.