public final class CurrentDevice
extends java.lang.Object
The device is selected in the Minecraft GUI and once it is selected, it can be controlled using commands (that call methods of this class in the background), by using Link API objects or in most cases by using this helper class.
Example usage of this class:
CurrentDevice.digitalWrite(13, 1);
In this example, the pin 13 of the currently connected device is set to logic level "high".
| Constructor and Description |
|---|
CurrentDevice() |
| Modifier and Type | Method and Description |
|---|---|
static short |
analogRead(int port)
This methods reads the analog level of the selected pin on the selected device.
|
static void |
analogWrite(int port,
short val)
This methods sets the analog level of the selected pin on the connected device to the given level.
|
static byte |
digitalRead(int port)
This methods reads the digital logic level of the selected pin on the selected device.
|
static void |
digitalWrite(int port,
byte val)
This methods sets the logic level of the selected pin on the connected to the given level.
|
static void |
disableDigitalInputEvents(int port)
Call this method to disable digital input events on the selected port.
|
static void |
enableDigitalInputEvents(int port)
Call this method to enable digital input events on the selected port.
|
static int |
getAnalogPinsCount()
Call this method to get the number of analog inputs the current device has
|
static int |
getDigitalPinsCount()
Call this method to get the number of digital inputs the current device has
|
static void |
pinMode(int port,
PinMode pinMode)
This method sets the pin mode of the selected pin on the current device.
|
static void |
sendMessage(java.lang.String message)
Call this method to send a custom message to the current device.
|
public static void pinMode(int port, PinMode pinMode)
Pin mode is the mode of the pin on the device. It can be input or output. There is a special mode input_pullup too, in which case the internal pullup resitor of the connected device is enabled if it is supported by the current device.
The output mode is used when one want to controll the logic level of the pin and input mode is used when one wants to check the input logic level of a pin on the device.
If there is no device connected, nothing happens.
port
- Port of which to set the pin modepinMode
- PinMode of the pin. Can be PinMode.OUT, PinMode.IN or PinMode.IN_Ppublic static void digitalWrite(int port, byte val)
If there is no device connected, nothing happens.
port
- Port on the device of which the logic level should be setval
- Logic level value - should be 0 for low or 1 for highpublic static void analogWrite(int port, short val)
If there is no device connected, nothing happens.
port
- Port on the device of which the analog level should be setval
- Value depends on the DAC resolution. For most devices, the interval goes from
0 for the lowest voltage level and 1024 for the highest voltage levelpublic static byte digitalRead(int port)
port
- Port on the device from which to read frompublic static short analogRead(int port)
port
- Port on the device from which to read frompublic static void enableDigitalInputEvents(int port)
If there is no device connected, nothing happens.
port
- Port on which to enable digital input eventsLinkDigitalPinChangedEvent
public static void disableDigitalInputEvents(int port)
If there is no device connected, nothing happens.
port
- Port on which to enable digital input eventsLinkDigitalPinChangedEvent
public static void sendMessage(java.lang.String message)
If there is no device connected, nothing happens.
message
- The message to be sentpublic static int getDigitalPinsCount()
public static int getAnalogPinsCount()


---
layout: default
---
Work Experience
Since Feb 2018 in Calgary, AB Canada
- Developed a Java-based RESTful API in Google AppEngine to interface with Google Datastore and process solar generation data on a per-minute basis
- Achieved high scalability by implementing a sharding system that adjusts to high contention from parallel data ingestion tasks on the fly
- Created a Google Sheets-based dashboard to gain valuable insights into the cost, performance, and state of the AppEngine application
- Maintained high confidence in the code base through full test coverage in unit and integration test suites
- Helped with developing a machine learning system to analyze solar generation data and detect anomalies
- Helped with implementing solutions to interface with external APIs and scrape websites in order to access solar inverter data
Intern / Trainee in Project Mgmt & Quality Assurance at Shore GmbH
Oct ‘13 – May ‘17 in Munich, Germany
- Gained software QA experience through manual and automated testing (regression, smoke, load, UAT, etc.) in an agile environment
- Built, automated, and maintained the company Business Intelligence reporting infrastructure for two years
- Assisted with feature design, wireframing, and competitor research
Jul ‘12 – Oct ‘12 in Beiseker, AB Canada
- Demonstrated my ability to take on responsibility by packing Solo student and Tandem parachuting gear
Skills
Programming Languages
- Good knowledge of
Java,
PHP,
Python
- Basic knowledge of
C#,
SQL,
JavaScript, HTML, CSS,
Flutter, Dart,
C/C++,
Haskell, Prolog,
Bash,
ARM Assembly
Tools
- GCP AppEngine, Git, Travis, Maven, Jetbrains IDEs, Docker,
Unity3D,
Firebase
- Comfortable working in Linux and Windows environments
Other
- OOP, MVC, NoSQL (Google Datastore), Scrum/Kanban, Software development practices and clean code, Developing & using APIs, Machine Learning, Software QA
- Excellent team, communication, and organization skills
- English (fluent), German (native)
Education
B.Sc. Computer Science at UCalgary
Sep ‘15 – Apr ‘18
B.A. North American Studies & Communication Science at LMU Munich
Oct ‘12 – Feb ‘15
Hobbies & Interests
- Designing, developing, researching, and playing video games
- Spending time with my pet rabbits, bearded dragon, betta fish,
19 tarantulas, and
corgi
- Working on personal projects, such Tarantula Identifier, an Android app for identifying tarantula species using Google Firebase and AutoML Vision Edge
- Soccer, Skydiving, Ballroom Dance, and various other sports


The public bus
We didn’t find it…. but it was a new system. It's a bus that stop in all the main beach
(no drop off at hotels, they stop by the Beaches) it’s a city bus and can be filled with
a lot of people. If you take this option remember that you can only pay with the exact
amount of money. They won’t have change. It’s the cheapest option and that one (correct
me if i am wrong) doesn’t stop at a travel agency.
The tourist bus
There's a few agency at the airport that propose bus ride to different beach/town on the
island. (They are really easy to spot and if you don't see them, they will see you)
Basically they pack around 10 person in a van with A.C and drop you off at your hotel.
Compared to what I was expecting it’s not very expensive. Only 20 baht more than the
public bus so 160 baht to go to park g beach witch is 1 hour drive.  They make a stop at a traveling agency where they will
try to sell you tour and trip. Don’t worry if you tell them you are not interested they
back off really fast. You just have to wait for everyone to finish booking their tours
and you go back on your way.
Taxi/grab
As in any airport you will find an endless amount of taxi ready to take you wherever you
want and they won't forget to charge you the airport fee. It’s the most expensive option
but also the least worry and fastest.
Motorbike (inexpensive)
You can hop on the back of a Motorcycle (Grab motorbike ride). It's interesting if you
are traveling light and staying in the town of phuket (yes the island have a town call
the same way… It’s a classic) I don’t recommend that option as it may be stressful
(traffic…) and hurt your butt… patong beach is 1h away from phuket airport. So doing the
transport squeezed on a bike with luggage promise to be fun.


; ; ------------------------------------------------------------ ; ; PureBasic - Drawing via Direct Screen Access (DSA) ; ; (c) Fantaisie Software ; ; ------------------------------------------------------------ ; ; Note: disable the debugger to run at full speed ! ; #ScreenWidth = 800 ; Feel free to change this to see the pixel filling speed ! #ScreenHeight = 600 If InitSprite() = 0 Or InitKeyboard() = 0 MessageRequester("Error", "DirectX is needed.",0) EndIf Structure Pixel Pixel.l EndStructure Procedure.f GSin(angle.f) ProcedureReturn Sin(angle*(2*3.14/360)) EndProcedure ; Pre-calculated values are faster than realtime calculated ones... ; ... so we save them in an array before starting gfx operations Dim CosTable(#ScreenWidth*2) Dim ColorTable(255) For i = 0 To #ScreenWidth*2 CosTable(i) = GSin(360*i/320)* 32 + 32 Next If OpenScreen(#ScreenWidth, #ScreenHeight, 32, "PB Plasma") Repeat Wave+6 If Wave > 320 : Wave = 0 : EndIf If StartDrawing(ScreenOutput()) Buffer = DrawingBuffer() ; Get the start address of the screen buffer Pitch = DrawingBufferPitch() ; Get the length (in byte) took by one horizontal line PixelFormat = DrawingBufferPixelFormat() ; Get the pixel format. If PixelFormat = #PB_PixelFormat_32Bits_RGB For i = 0 To 255 ColorTable(i) = i << 16 ; Blue is at the 3th pixel Next Else ; Else it's 32bits_BGR For i = 0 To 255 ColorTable(i) = i ; Blue is at the 1th pixel Next EndIf For y = 0 To #ScreenHeight-1 pos1 = CosTable(y+wave) *Line.Pixel = Buffer+Pitch*y For x = 0 To #ScreenWidth-1 pos2 = (CosTable(x+Wave) + CosTable(x+y) + pos1) *Line\Pixel = ColorTable(pos2) ; Write the pixel directly to the memory ! *Line+4 Next Next StopDrawing() EndIf ExamineKeyboard() FlipBuffers() Until KeyboardPushed(#PB_Key_Escape) Else MessageRequester("Error","Can't open the screen !",0) EndIf End


where text does not start with >
or ->
, does not end with -
,
and does not contain --
. (See the
HTML5 spec.)
A processing instruction
consists of the string <?
, a string
of characters not including the string ?>
, and the string
?>
.
A declaration consists of the string <!
, an ASCII letter, zero or more
characters not including the character >
, and the character >
.
A CDATA section consists of
the string <![CDATA[
, a string of characters not including the string
]]>
, and the string ]]>
.
An HTML tag consists of an [open tag], a [closing tag], an [HTML comment], a [processing instruction], a [declaration], or a [CDATA section].
Here are some simple open tags:
<bab><c2c>
.

<bab><c2c>

Empty elements:
<b2/>
.

<b2/>

Whitespace is allowed:
<b2
data="foo" >
.

<b2
data="foo" >

With attributes:
<a foo="bar" bam = 'baz "'
_boolean zoop:33=zoop:33 />
.

<a foo="bar" bam = 'baz "'
_boolean zoop:33=zoop:33 />

Custom tag names can be used:
Foo <responsive-image src="foo.jpg" />
.

Foo <responsive-image src="foo.jpg" />

Illegal tag names, not parsed as HTML:
<33> <__>
.

<33> <__>

Illegal attribute names:

.

Illegal attribute values:

.

Illegal whitespace:
<
foo><bar/ >
<foo bar=baz
bim!bop />
.

<
foo><bar/ >
<foo bar=baz
bim!bop />

Missing whitespace:

.

Closing tags:
</foo >
.

</foo >

Illegal attributes in closing tag:

.

Comments:
foo
.

foo

foo
.

foo

Not comments:
foo
foo
.

foo

foo

Processing instructions:
foo <?php echo $a; ?>
.

foo <?php echo $a; ?>

Declarations:
foo <!ELEMENT br EMPTY>
.

foo <!ELEMENT br EMPTY>

CDATA sections:
foo <![CDATA[>&<]]>
.

foo <![CDATA[>&<]]>

Entity and numeric character references are preserved in HTML attributes:
foo
.

foo

Backslash escapes do not work in HTML attributes:
foo
.

foo

.

A line ending (not in a code span or HTML tag) that is preceded
by two or more spaces and does not occur at the end of a block
is parsed as a hard line break (rendered
in HTML as a

tag):
foo
baz
.

foo

baz

For a more visible alternative, a backslash before the [line ending] may be used instead of two or more spaces:
foo\
baz
.

foo

baz

More than two spaces can be used:
foo
baz
.

foo

baz

Leading spaces at the beginning of the next line are ignored:
foo
bar
.

foo

bar

foo\
bar
.

foo

bar

Hard line breaks can occur inside emphasis, links, and other constructs that allow inline content:
*foo
bar*
.

foo

bar

*foo\
bar*
.

foo

bar

Hard line breaks do not occur inside code spans
`code
span`
.

code span

`code\
span`
.

code\ span

or HTML tags:

.

.

Hard line breaks are for separating inline content within a block. Neither syntax for hard line breaks works at the end of a paragraph or other block element:
foo\
.

foo\

foo
.

foo

### foo\
.

foo\

### foo
.

foo

A regular line ending (not in a code span or HTML tag) that is not preceded by two or more spaces or a backslash is parsed as a softbreak. (A soft line break may be rendered in HTML either as a [line ending] or as a space. The result will be the same in browsers. In the examples here, a [line ending] will be used.)
foo
baz
.

foo
baz

Spaces at the end of the line and beginning of the next line are removed:
foo
baz
.

foo
baz

A conforming parser may render a soft line break in HTML either as a line ending or as a space.
A renderer may also provide an option to render soft line breaks as hard line breaks.
Any characters not given an interpretation by the above rules will be parsed as plain textual content.
hello $.;'there
.

hello $.;'there

Foo χρῆν
.

Foo χρῆν

Internal spaces are preserved verbatim:
Multiple spaces
.

Multiple spaces

In this appendix we describe some features of the parsing strategy used in the CommonMark reference implementations.
Parsing has two phases:
In the first phase, lines of input are consumed and the block structure of the document---its division into paragraphs, block quotes, list items, and so on---is constructed. Text is assigned to these blocks but not parsed. Link reference definitions are parsed and a map of links is constructed.
In the second phase, the raw text contents of paragraphs and headings are parsed into sequences of Markdown inline elements (strings, code spans, links, emphasis, and so on), using the map of link references constructed in phase 1.
At each point in processing, the document is represented as a tree of
blocks. The root of the tree is a document
block. The document
may have any number of other blocks as children. These children
may, in turn, have other blocks as children. The last child of a block
is normally considered open, meaning that subsequent lines of input
can alter its contents. (Blocks that are not open are closed.)
Here, for example, is a possible document tree, with the open blocks
marked by arrows:
-> document
-> block_quote
paragraph
"Lorem ipsum dolor\nsit amet."
-> list (type=bullet tight=true bullet_char=-)
list_item
paragraph
"Qui *quodsi iracundia*"
-> list_item
-> paragraph
"aliquando id"
Each line that is processed has an effect on this tree. The line is analyzed and, depending on its contents, the document may be altered in one or more of the following ways:
Once a line has been incorporated into the tree in this way, it can be discarded, so input can be read in a stream.
For each line, we follow this procedure:
First we iterate through the open blocks, starting with the
root document, and descending through last children down to the last
open block. Each block imposes a condition that the line must satisfy
if the block is to remain open. For example, a block quote requires a
>
character. A paragraph requires a non-blank line.
In this phase we may match all or just some of the open
blocks. But we cannot close unmatched blocks yet, because we may have a
[lazy continuation line].
Next, after consuming the continuation markers for existing
blocks, we look for new block starts (e.g. >
for a block quote).
If we encounter a new block start, we close any blocks unmatched
in step 1 before creating the new block as a child of the last
matched container block.
Finally, we look at the remainder of the line (after block
markers like >
, list markers, and indentation have been consumed).
This is text that can be incorporated into the last open
block (a paragraph, code block, heading, or raw HTML).
Setext headings are formed when we see a line of a paragraph that is a [setext heading underline].
Reference link definitions are detected when a paragraph is closed; the accumulated text lines are parsed to see if they begin with one or more reference link definitions. Any remainder becomes a normal paragraph.
We can see how this works by considering how the tree above is generated by four lines of Markdown:
> Lorem ipsum dolor
sit amet.
> - Qui *quodsi iracundia*
> - aliquando id
At the outset, our document model is just
-> document
The first line of our text,
> Lorem ipsum dolor
causes a block_quote
block to be created as a child of our
open document
block, and a paragraph
block as a child of
the block_quote
. Then the text is added to the last open
block, the paragraph
:
-> document
-> block_quote
-> paragraph
"Lorem ipsum dolor"
The next line,
sit amet.
is a "lazy continuation" of the open paragraph
, so it gets added
to the paragraph's text:
-> document
-> block_quote
-> paragraph
"Lorem ipsum dolor\nsit amet."
The third line,
> - Qui *quodsi iracundia*
causes the paragraph
block to be closed, and a new list
block
opened as a child of the block_quote
. A list_item
is also
added as a child of the list
, and a paragraph
as a child of
the list_item
. The text is then added to the new paragraph
:
-> document
-> block_quote
paragraph
"Lorem ipsum dolor\nsit amet."
-> list (type=bullet tight=true bullet_char=-)
-> list_item
-> paragraph
"Qui *quodsi iracundia*"
The fourth line,
> - aliquando id
causes the list_item
(and its child the paragraph
) to be closed,
and a new list_item
opened up as child of the list
. A paragraph
is added as a child of the new list_item
, to contain the text.
We thus obtain the final tree:
-> document
-> block_quote
paragraph
"Lorem ipsum dolor\nsit amet."
-> list (type=bullet tight=true bullet_char=-)
list_item
paragraph
"Qui *quodsi iracundia*"
-> list_item
-> paragraph
"aliquando id"
Once all of the input has been parsed, all open blocks are closed.
We then "walk the tree," visiting every node, and parse raw string contents of paragraphs and headings as inlines. At this point we have seen all the link reference definitions, so we can resolve reference links as we go.
document
block_quote
paragraph
str "Lorem ipsum dolor"
softbreak
str "sit amet."
list (type=bullet tight=true bullet_char=-)
list_item
paragraph
str "Qui "
emph
str "quodsi iracundia"
list_item
paragraph
str "aliquando id"
Notice how the [line ending] in the first paragraph has
been parsed as a softbreak
, and the asterisks in the first list item
have become an emph
.
By far the trickiest part of inline parsing is handling emphasis, strong emphasis, links, and images. This is done using the following algorithm.
When we're parsing inlines and we hit either
*
or _
characters, or[
or ![
we insert a text node with these symbols as its literal content, and we add a pointer to this text node to the delimiter stack.
The [delimiter stack] is a doubly linked list. Each element contains a pointer to a text node, plus information about
[
, ![
, *
, _
)When we hit a ]
character, we call the look for link or image
procedure (see below).
When we hit the end of the input, we call the process emphasis
procedure (see below), with stack_bottom
= NULL.
Starting at the top of the delimiter stack, we look backwards
through the stack for an opening [
or ![
delimiter.
If we don't find one, we return a literal text node ]
.
If we do find one, but it's not active, we remove the inactive
delimiter from the stack, and return a literal text node ]
.
If we find one and it's active, then we parse ahead to see if we have an inline link/image, reference link/image, compact reference link/image, or shortcut reference link/image.
If we don't, then we remove the opening delimiter from the
delimiter stack and return a literal text node ]
.
If we do, then
We return a link or image node whose children are the inlines after the text node pointed to by the opening delimiter.
We run process emphasis on these inlines, with the [
opener
as stack_bottom
.
We remove the opening delimiter.
If we have a link (and not an image), we also set all
[
delimiters before the opening delimiter to inactive. (This
will prevent us from getting links within links.)
Parameter stack_bottom
sets a lower bound to how far we
descend in the [delimiter stack]. If it is NULL, we can
go all the way to the bottom. Otherwise, we stop before
visiting stack_bottom
.
Let current_position
point to the element on the [delimiter stack]
just above stack_bottom
(or the first element if stack_bottom
is NULL).
We keep track of the openers_bottom
for each delimiter
type (*
, _
), indexed to the length of the closing delimiter run
(modulo 3) and to whether the closing delimiter can also be an
opener. Initialize this to stack_bottom
.
Then we repeat the following until we run out of potential closers:
Move current_position
forward in the delimiter stack (if needed)
until we find the first potential closer with delimiter *
or _
.
(This will be the potential closer closest
to the beginning of the input -- the first one in parse order.)
Now, look back in the stack (staying above stack_bottom
and
the openers_bottom
for this delimiter type) for the
first matching potential opener ("matching" means same delimiter).
If one is found:
Figure out whether we have emphasis or strong emphasis: if both closer and opener spans have length >= 2, we have strong, otherwise regular.
Insert an emph or strong emph node accordingly, after the text node corresponding to the opener.
Remove any delimiters between the opener and closer from the delimiter stack.
Remove 1 (for regular emph) or 2 (for strong emph) delimiters
from the opening and closing text nodes. If they become empty
as a result, remove them and remove the corresponding element
of the delimiter stack. If the closing node is removed, reset
current_position
to the next element in the stack.
If none is found:
Set openers_bottom
to the element before current_position
.
(We know that there are no openers for this kind of closer up to and
including this point, so this puts a lower bound on future searches.)
If the closer at current_position
is not a potential opener,
remove it from the delimiter stack (since we know it can't
be a closer either).
Advance current_position
to the next element in the stack.
After we're done, we remove all delimiters above stack_bottom
from the
delimiter stack.


{# Versions here and in home.py must be kept in sync! #} {% block css_page %} {% end %} {# NOTE: jQuery JS has to be loaded before bootstrap JS! #}


Implementing a Custom Source Connector for Table API and SQL - Part One
September 7, 2021 - Ingo Buerk Daisy TsangPart one of this tutorial will teach you how to build and run a custom source connector to be used with Table API and SQL, two high-level abstractions in Flink. The tutorial comes with a bundled docker-compose setup that lets you easily run the connector. You can then try it out with Flink’s SQL client.
Introduction #
Apache Flink is a data processing engine that aims to keep state locally in order to do computations efficiently. However, Flink does not “own” the data but relies on external systems to ingest and persist data. Connecting to external data input (sources) and external data storage (sinks) is usually summarized under the term connectors in Flink.
Since connectors are such important components, Flink ships with connectors for some popular systems. But sometimes you may need to read in an uncommon data format and what Flink provides is not enough. This is why Flink also provides extension points for building custom connectors if you want to connect to a system that is not supported by an existing connector.
Once you have a source and a sink defined for Flink, you can use its declarative APIs (in the form of the Table API and SQL) to execute queries for data analysis.
The Table API provides more programmatic access while SQL is a more universal query language. It is named Table API because of its relational functions on tables: how to obtain a table, how to output a table, and how to perform query operations on the table.
In this two-part tutorial, you will explore some of these APIs and concepts by implementing your own custom source connector for reading in data from an email inbox. You will then use Flink to process emails through the IMAP protocol.
Part one will focus on building a custom source connector and part two will focus on integrating it.
Prerequisites #
This tutorial assumes that you have some familiarity with Java and objected-oriented programming.
You are encouraged to follow along with the code in this repository.
It would also be useful to have docker-compose installed on your system in order to use the script included in the repository that builds and runs the connector.
Understand the infrastructure required for a connector #
In order to create a connector which works with Flink, you need:
-
A factory class (a blueprint for creating other objects from string properties) that tells Flink with which identifier (in this case, “imap”) our connector can be addressed, which configuration options it exposes, and how the connector can be instantiated. Since Flink uses the Java Service Provider Interface (SPI) to discover factories located in different modules, you will also need to add some configuration details.
-
The table source object as a specific instance of the connector during the planning stage. It is responsible for back and forth communication with the optimizer during the planning stage and is like another factory for creating connector runtime implementation. There are also more advanced features, such as abilities, that can be implemented to improve connector performance.
-
A runtime implementation from the connector obtained during the planning stage. The runtime logic is implemented in Flink’s core connector interfaces and does the actual work of producing rows of dynamic table data. The runtime instances are shipped to the Flink cluster.
Let us look at this sequence (factory class → table source → runtime implementation) in reverse order.
Establish the runtime implementation of the connector #
You first need to have a source connector which can be used in Flink’s runtime system, defining how data goes in and how it can be executed in the cluster. There are a few different interfaces available for implementing the actual source of the data and have it be discoverable in Flink.
For complex connectors, you may want to implement the Source interface which gives you a lot of control. For simpler use cases, you can use the SourceFunction interface. There are already a few different implementations of SourceFunction interfaces for common use cases such as the FromElementsFunction class and the RichSourceFunction class. You will use the latter.
Hint
The Source interface is the new abstraction whereas the SourceFunction interface is slowly phasing out. All connectors will eventually implement the Source interface.
RichSourceFunction
is a base class for implementing a data source that has access to context information and some lifecycle methods. There is a run()
method inherited from the SourceFunction
interface that you need to implement. It is invoked once and can be used to produce the data either once for a bounded result or within a loop for an unbounded stream.
For example, to create a bounded data source, you could implement this method so that it reads all existing emails and then closes. To create an unbounded source, you could only look at new emails coming in while the source is active. You can also combine these behaviors and expose them through configuration options.
When you first create the class and implement the interface, it should look something like this:
import org.apache.flink.streaming.api.functions.source.RichSourceFunction;
import org.apache.flink.table.data.RowData;
public class ImapSource extends RichSourceFunction<RowData> {
@Override
public void run(SourceContext<RowData> ctx) throws Exception {}
@Override
public void cancel() {}
}
Note that internal data structures (RowData
) are used because that is required by the table runtime.
In the run()
method, you get access to a context object inherited from the SourceFunction interface, which is a bridge to Flink and allows you to output data. Since the source does not produce any data yet, the next step is to make it produce some static data in order to test that the data flows correctly:
import org.apache.flink.streaming.api.functions.source.RichSourceFunction;
import org.apache.flink.table.data.GenericRowData;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.data.StringData;
public class ImapSource extends RichSourceFunction<RowData> {
@Override
public void run(SourceContext<RowData> ctx) throws Exception {
ctx.collect(GenericRowData.of(
StringData.fromString("Subject 1"),
StringData.fromString("Hello, World!")
));
}
@Override
public void cancel(){}
}
You do not need to implement the cancel()
method yet because the source finishes instantly.
Create and configure a dynamic table source for the data stream #
Dynamic tables are the core concept of Flink’s Table API and SQL support for streaming data and, like its name suggests, change over time. You can imagine a data stream being logically converted into a table that is constantly changing. For this tutorial, the emails that will be read in will be interpreted as a (source) table that is queryable. It can be viewed as a specific instance of a connector class.
You will now implement a DynamicTableSource interface. There are two types of dynamic table sources: ScanTableSource and LookupTableSource. Scan sources read the entire table on the external system while lookup sources look for specific rows based on keys. The former will fit the use case of this tutorial.
This is what a scan table source implementation would look like:
import org.apache.flink.table.connector.ChangelogMode;
import org.apache.flink.table.connector.source.DynamicTableSource;
import org.apache.flink.table.connector.source.ScanTableSource;
import org.apache.flink.table.connector.source.SourceFunctionProvider;
public class ImapTableSource implements ScanTableSource {
@Override
public ChangelogMode getChangelogMode() {
return ChangelogMode.insertOnly();
}
@Override
public ScanRuntimeProvider getScanRuntimeProvider(ScanContext ctx) {
boolean bounded = true;
final ImapSource source = new ImapSource();
return SourceFunctionProvider.of(source, bounded);
}
@Override
public DynamicTableSource copy() {
return new ImapTableSource();
}
@Override
public String asSummaryString() {
return "IMAP Table Source";
}
}
ChangelogMode informs Flink of expected changes that the planner can expect during runtime. For example, whether the source produces only new rows, also updates to existing ones, or whether it can remove previously produced rows. Our source will only produce (insertOnly()
) new rows.
ScanRuntimeProvider allows Flink to create the actual runtime implementation you established previously (for reading the data). Flink even provides utilities like SourceFunctionProvider to wrap it into an instance of SourceFunction, which is one of the base runtime interfaces.
You will also need to indicate whether the source is bounded or not. Currently, this is the case but you will have to change this later.
Create a factory class for the connector so it can be discovered by Flink #
You now have a working source connector, but in order to use it in Table API or SQL, it needs to be discoverable by Flink. You also need to define how the connector is addressable from a SQL statement when creating a source table.
You need to implement a Factory, which is a base interface that creates object instances from a list of key-value pairs in Flink’s Table API and SQL. A factory is uniquely identified by its class name and factoryIdentifier()
. For this tutorial, you will implement the more specific DynamicTableSourceFactory, which allows you to configure a dynamic table connector as well as create DynamicTableSource
instances.
import java.util.HashSet;
import java.util.Set;
import org.apache.flink.configuration.ConfigOption;
import org.apache.flink.table.connector.source.DynamicTableSource;
import org.apache.flink.table.factories.DynamicTableSourceFactory;
import org.apache.flink.table.factories.FactoryUtil;
public class ImapTableSourceFactory implements DynamicTableSourceFactory {
@Override
public String factoryIdentifier() {
return "imap";
}
@Override
public Set<ConfigOption<?>> requiredOptions() {
return new HashSet<>();
}
@Override
public Set<ConfigOption<?>> optionalOptions() {
return new HashSet<>();
}
@Override
public DynamicTableSource createDynamicTableSource(Context ctx) {
final FactoryUtil.TableFactoryHelper factoryHelper = FactoryUtil.createTableFactoryHelper(this, ctx);
factoryHelper.validate();
return new ImapTableSource();
}
}
There are currently no configuration options but they can be added and also validated within the createDynamicTableSource()
function. There is a small helper utility, TableFactoryHelper, that Flink offers which ensures that required options are set and that no unknown options are provided.
Finally, you need to register your factory for Java’s Service Provider Interfaces (SPI). Classes that implement this interface can be discovered and should be added to this file src/main/resources/META-INF/services/org.apache.flink.table.factories.Factory
with the fully classified class name of your factory:
// if you created your class in the package org.example.acme, it should be named the following:
org.example.acme.ImapTableSourceFactory
Test the custom connector #
You should now have a working source connector. If you are following along with the provided repository, you can test it by running:
$ cd testing/
$ ./build_and_run.sh
This builds the connector, starts a Flink cluster, a test email server (which you will need later), and the SQL client (which is bundled in the regular Flink distribution) for you. If successful, you should see the SQL CLI:
Flink SQL Client
You can now create a table (with a “subject” column and a “content” column) with your connector by executing the following statement with the SQL client:
CREATE TABLE T (subject STRING, content STRING) WITH ('connector' = 'imap');
SELECT * FROM T;
Note that the schema must be exactly as written since it is currently hardcoded into the connector.
You should be able to see the static data you provided in your source connector earlier, which would be “Subject 1” and “Hello, World!”.
Now that you have a working connector, the next step is to make it do something more useful than returning static data.
Summary #
In this tutorial, you looked into the infrastructure required for a connector and configured its runtime implementation to define how it should be executed in a cluster. You also defined a dynamic table source that reads the entire stream-converted table from the external source, made the connector discoverable by Flink through creating a factory class for it, and then tested it.
Next Steps #
In part two, you will integrate this connector with an email inbox through the IMAP protocol.


Sort by
- Alphabetical
- Most popular
- Recent
Cs
Computer Science 10 notes
- 17/10/14 Monotone chain convex hull
- 11/10/14 Threads vs. processes
- 24/09/14 Tarjan's algorithm for finding SCCs
Ma
Mathematics 8 notes
- 11/10/14 Pick's theorem: idea and a proof
- 21/09/14 Complex exponential function
- 17/09/14 Newton's method for approximate equation solving
Ph
Physics 5 notes
- 17/10/14 Tensile, bulk and shear strain
- 17/10/14 Idea of Lagrangian mechanics
- 17/10/14 Incorrectness of Kirchoff's II. law
Hi
History 4 notes
- 17/10/14 Pick's theorem: idea and a proof
- 17/10/14 Complex exponential function
- 17/10/14 Newton's method for approximate equation solving
Lo
Logic 2 notes
- 17/10/14 Pick's theorem: idea and a proof
- 17/10/14 Complex exponential function
Pl
Philosophy 1 note
- 17/10/14 Pick's theorem: idea and a proof


3 Data Wrangling
Nearly all datasets require some initial procedures (e.g., cleaning, reformatting, reshaping) to be applied before we start running any statistical analysis or creating visualizations. These procedures are often referred to as data wrangling. Here is a nice summary of the data wrangling process:
In this section, we will follow the steps of data wrangling as shown above.
3.1 Creating Datasets in R
There are multiple ways of creating datasets in R. We can create individual variables and combine them using the cbind
(column bind) command:
<- c(21, 24, 32, 45, 52)
age <- c(4500, 3500, 4100, 4700, 6000)
salary <- cbind(age, salary)
mydata mydata
age salary
[1,] 21 4500
[2,] 24 3500
[3,] 32 4100
[4,] 45 4700
[5,] 52 6000
We can also create individual rows and combine them using the rbind
(row bind) command (though this is not practical if there are many rows):
<- c(21, 4500)
person1 <- c(24, 3500)
person2 <- c(32, 4100)
person3 <- c(45, 4700)
person4 <- c(52, 6000)
person5
<- rbind(person1, person2, person3, person4, person5)
mydata mydata
[,1] [,2]
person1 21 4500
person2 24 3500
person3 32 4100
person4 45 4700
person5 52 6000
A better way to create datasets in R is to define variables within a data frame using the data.frame
command.
<- data.frame(age = c(21, 24, 32, 45, 52),
mydata salary = c(4500, 3500, 4100, 4700, 6000))
mydata
age salary
1 21 4500
2 24 3500
3 32 4100
4 45 4700
5 52 6000
Data frames in R are very convenient because many mathematical operations can be directly applied to a data frame or some columns (or rows) of a data frame. Once a data frame is defined in R, we can see its content using the View
command (which open the data window) or the head
command (which prints the first six rows of the data):
# To print the first six rows of a data frame
head(mydata)
# To see the entire data in the view window
View(mydata)
3.2 Importing Data into R
We often save our data sets in convenient data formats, such as Excel, SPSS, or text files (.txt, .csv, .dat, etc.). R is capable of importing (i.e., reading) various data formats.
There are two ways to import a data set into R:
- By using the “Import Dataset” menu option in RStudio
- By using a particular R command
3.2.1 Method 1: Using RStudio
<IP_ADDRESS> Importing Excel Files
- Browse for the file that you want to import
- Give a name for the data set
- Choose the sheet to be imported
- “First Row as Names” if the variable names are in the first row of the file.
<IP_ADDRESS> Importing SPSS Files
- Browse the file that you want to import
- Give a name for the data set
- Choose the SPSS data format (SAV)
3.2.2 Method 2: Using R Commands
R has some built-in functions, such as read.csv
and read.table
. Also, there are R packages for importing specific data formats. For example, foreign
for SPSS files and xlsx
for Excel files. Here are some examples:
Excel Files:
# Install and activate the package first
install.packages("xlsx")
library("xlsx")
# Use read.xlsx to import an Excel file
<- read.xlsx("path to the file/filename.xlsx", sheetName = "sheetname") my_excel_file
SPSS Files:
# Install and activate the package first
install.packages("foreign")
library("foreign")
# Use read.spss to import an SPSS file
<- read.spss("path to the file/filename.sav", to.data.frame = TRUE) my_spss_file
Text Files:
# No need to install any packages
# R has many built-in functions already
# A comma-separated-values file with a .csv extension
<- read.csv("path to the file/filename.csv", header = TRUE)
my_csv_file
# A tab delimited text file with .txt extension
<- read.table("path to the file/filename.txt", header = TRUE, sep = "\t") my_txt_file
Here we should note that:
header = TRUE
if the variable names are in the first row; otherwise, useheader = FALSE
sep="\t"
for tab-separated files;sep=","
for comma-separated files
3.2.3 Exercise 3
Now we will import the medical
dataset into R. The dataset comes from a clinical study. Patients with no primary care physician were randomized to receive a multidisciplinary assessment and a brief motivational intervention, with the goal of linking them to primary medical care. You can find the details in “Codebook for the medical Dataset” in your folder. Our dataset is in a .csv format (medical.csv
).
- Import the file
medical.csv
by using theread.csv
command and save it asmedical
using the following code (assuming that the file is in your working directory):
<- read.csv("medical.csv", header = TRUE) medical
- Once the data file is successfully imported, run the following to see the first six rows of the data:
head(medical)
You should be able to see the output below:
id age sex race homeless substance avg_drinks max_drinks suicidal treat
1 1 37 male black housed cocaine 13 26 yes yes
2 2 37 male white homeless alcohol 56 62 yes yes
3 3 26 male black housed heroin 0 0 no no
4 4 39 female white housed heroin 5 5 no no
5 5 32 male black homeless cocaine 10 13 no no
6 6 47 female black housed cocaine 4 4 no yes
physical1 mental1 depression1 physical2 mental2 depression2
1 58.41 25.112 49 54.23 52.23 7
2 36.04 26.670 30 59.56 41.73 11
3 74.81 6.763 39 58.46 56.77 14
4 61.93 43.968 15 46.61 14.66 44
5 37.35 21.676 39 31.42 40.67 26
6 46.48 55.509 6 43.20 50.06 23
3.3 Understanding the Data
After we import a dataset into R, we can quickly check a few things to understand our dataset better:
- To see the number of rows in the data:
nrow(medical)
[1] 246
- To see the number of columns in the data:
ncol(medical)
[1] 16
- To see its dimensions all together:
dim(medical)
[1] 246 16
- To see all of the variable names in the data:
names(medical)
[1] "id" "age" "sex" "race" "homeless"
[6] "substance" "avg_drinks" "max_drinks" "suicidal" "treat"
[11] "physical1" "mental1" "depression1" "physical2" "mental2"
[16] "depression2"
- To see the structure of the entire dataset:
str(medical)
'data.frame': 246 obs. of 16 variables:
$ id : int 1 2 3 4 5 6 8 9 10 12 ...
$ age : int 37 37 26 39 32 47 28 50 39 58 ...
$ sex : chr "male" "male" "male" "female" ...
$ race : chr "black" "white" "black" "white" ...
$ homeless : chr "housed" "homeless" "housed" "housed" ...
$ substance : chr "cocaine" "alcohol" "heroin" "heroin" ...
$ avg_drinks : int 13 56 0 5 10 4 12 71 20 13 ...
$ max_drinks : int 26 62 0 5 13 4 24 129 27 13 ...
$ suicidal : chr "yes" "yes" "no" "no" ...
$ treat : chr "yes" "yes" "no" "no" ...
$ physical1 : num 58.4 36 74.8 61.9 37.3 ...
$ mental1 : num 25.11 26.67 6.76 43.97 21.68 ...
$ depression1: int 49 30 39 15 39 6 32 50 46 49 ...
$ physical2 : num 54.2 59.6 58.5 46.6 31.4 ...
$ mental2 : num 52.2 41.7 56.8 14.7 40.7 ...
$ depression2: int 7 11 14 44 26 23 18 33 37 8 ...
3.4 Indexing
In R, each row and column is indexed by the position they appear in the data. R uses square brackets for indexing. Within the square brackets, the first number shows the row number(s) and the second number shows the column(s). To call a particular column (i.e., variables) or a particular row (i.e., persons), we can use the following structure: data[row, col]
For example, if we want to see the second variable for the fifth person in the medical
dataset:
5, 2] medical[
[1] 32
Or, if we want to see the first three variables for the first five persons:
1:5, 1:3] medical[
id age sex
1 1 37 male
2 2 37 male
3 3 26 male
4 4 39 female
5 5 32 male
Instead of medical[1:5, 1:3]
, we could also do:
c(1, 2, 3, 4, 5), c(1, 2, 3)] medical[
id age sex
1 1 37 male
2 2 37 male
3 3 26 male
4 4 39 female
5 5 32 male
or
c(1, 2, 3, 4, 5), c("id", "age", "sex")] medical[
id age sex
1 1 37 male
2 2 37 male
3 3 26 male
4 4 39 female
5 5 32 male
A common way of indexing variables (i.e., columns) in R is to use the dollar sign with a variable name from a data frame. For example, we can select the age variable as follows:
$age medical
This would print all the values for age in the medical
dataset. We can also preview a particular variable using the head
function.
head(medical$age)
[1] 37 37 26 39 32 47
Using a particular variable, we can also see the values for some rows in the data. For example, let’s print the age variable for the 10th to 15th rows in the medical
dataset.
$age[10:15]
medical
# or
$age[c(10, 11, 12, 13, 14, 15)] medical
Note that now the brackets don’t need a comma inside as we had before. This is because we have already selected a variable (age) and so R knows that we now refer to rows when we type any values inside the brackets.
3.5 Subsetting
Now assume that we want to create a new dataset with only females from the medical
dataset. Although we can subset the data in many ways, the following two are the easiest:
- Using the
subset
function in base R:
<- subset(medical, sex == "female")
medical_female head(medical_female)
id age sex race homeless substance avg_drinks max_drinks suicidal
4 4 39 female white housed heroin 5 5 no
6 6 47 female black housed cocaine 4 4 no
8 9 50 female white homeless alcohol 71 129 no
10 12 58 female black housed alcohol 13 13 no
14 17 28 female hispanic homeless heroin 0 0 yes
17 20 27 female white housed heroin 9 24 yes
treat physical1 mental1 depression1 physical2 mental2 depression2
4 no 61.93 43.97 15 46.61 14.66 44
6 yes 46.48 55.51 6 43.20 50.06 23
8 no 38.27 22.03 50 45.56 28.88 33
10 no 41.93 13.38 49 52.96 51.45 8
14 yes 44.78 29.80 35 52.69 46.59 19
17 yes 37.45 15.46 52 61.40 41.53 15
Here we use a single selection criterion as sex == "female"
. We can also subset the data based on multiple criteria and select only some variables from our original data. Let’s assume that we want to select participants who are female and 40 years old or older. Also, we only want to keep the following variables in the dataset: id, age, sex, substance. Using the subset
function, we can do this selection as follows:
<- subset(medical, sex == "female" & age >= 40,
medical_f40 select = c("id", "age", "sex", "substance"))
head(medical_f40)
id age sex substance
6 6 47 female cocaine
8 9 50 female alcohol
10 12 58 female alcohol
21 27 48 female cocaine
51 65 41 female alcohol
56 71 40 female alcohol
- Using the
filter
function from thedplyr
package (an amazing package for data wrangling):
# Install and activate the package first
install.packages("dplyr")
library("dplyr")
<- filter(medical, sex == "female")
medical_female head(medical_female)
id age sex race homeless substance avg_drinks max_drinks suicidal
1 4 39 female white housed heroin 5 5 no
2 6 47 female black housed cocaine 4 4 no
3 9 50 female white homeless alcohol 71 129 no
4 12 58 female black housed alcohol 13 13 no
5 17 28 female hispanic homeless heroin 0 0 yes
6 20 27 female white housed heroin 9 24 yes
treat physical1 mental1 depression1 physical2 mental2 depression2
1 no 61.93 43.97 15 46.61 14.66 44
2 yes 46.48 55.51 6 43.20 50.06 23
3 no 38.27 22.03 50 45.56 28.88 33
4 no 41.93 13.38 49 52.96 51.45 8
5 yes 44.78 29.80 35 52.69 46.59 19
6 yes 37.45 15.46 52 61.40 41.53 15
Using the filter
and select
functions from the dplyr
package, we can also subset the dataset based on multiple criteria and select some variables from the dataset:
# Filter the data first
<- filter(medical, sex == "female", age >= 40)
medical_f40
# Select the variables to be keep
<- select(medical_f40, id, age, sex, substance)
medical_f40
# Preview the data
head(medical_f40)
There is also a more practical way to accomplish the same task. Here I will demonstrate %>%
, which is called the pipe operator. This operator forwards the result of a function to the next function. This way we can simplify the code without creating many intermediate datasets (see https://uc-r.github.io/pipe for more details on the pipe).
<- medical %>% # Send the medical data to filter
medical_f40 filter(sex == "female", age >= 40) %>% # Filter the data and send it to select
select(id, age, sex, substance) # Finally select the data
# Preview the data
head(medical_f40)
id age sex substance
1 6 47 female cocaine
2 9 50 female alcohol
3 12 58 female alcohol
4 27 48 female cocaine
5 65 41 female alcohol
6 71 40 female alcohol
Here are most common operators for subsetting:
<
Less than>
Greater than==
Equal to<=
Less than or equal to>=
Greater than or equal to!=
Not equal to%in%
Group membership&
And|
Oris.na
Is missing (NA).!is.na
Is not missing (NA)
3.6 Other Data Manipulation Tools
Here I will mention the other key functions from the dplyr
package. These functions solve the vast majority of data manipulation challenges:
arrange
: Reorder data based on values of variablesmutate
: Create new variablessummarise
: Summarize data by functions of choice
Arrange:
# Reorder the data by age
<- arrange(medical_f40, age)
medical_f40
# Let's see if the ordering worked
head(medical_f40)
id age sex substance
1 71 40 female alcohol
2 65 41 female alcohol
3 75 41 female heroin
4 121 42 female cocaine
5 465 42 female alcohol
6 364 43 female heroin
# Reorder the data by age in descending order
<- arrange(medical_f40, desc(age))
medical_f40
# Let's see if the ordering worked
head(medical_f40)
id age sex substance
1 12 58 female alcohol
2 181 57 female alcohol
3 264 55 female heroin
4 9 50 female alcohol
5 134 50 female alcohol
6 27 48 female cocaine
Mutate:
# Create a new variable based on age
<- medical_f40 %>%
medical_f40 mutate(age2 = ifelse(age < 45, "Younger than 45", "45 or older"))
# Let's see if the ordering worked
head(medical_f40)
id age sex substance age2
1 12 58 female alcohol 45 or older
2 181 57 female alcohol 45 or older
3 264 55 female heroin 45 or older
4 9 50 female alcohol 45 or older
5 134 50 female alcohol 45 or older
6 27 48 female cocaine 45 or older
We will use the summarise
function in the next section.
3.6.1 Exercise 4
Using the medical dataset, create a subset where the patients:
- are older than 30 years old:
age > 30
- are female:
sex == "female"
- are not homeless:
homeless != "homeless"
- are older than 30 years old:
and save this data as medical_example
. You can use either subset
or filter
for this task.
Use the
dim
function to see how many rows you have in the new dataSort this new dataset by age in descending order
Use the
head
function to preview the final dataset


Following more than six consecutive years with a federal funds rate of zero, the Fed has indicated that they are looking to raise interest rates some time before the end of 2015. When interest rates will go up, stock prices will be pulled down. There are multiple reasons for this. One way that stock prices are affected by higher interest rates, is that higher interest rates translate into more expensive loans, making the recycling of debt, as well as new debt, more expensive. Another reason is that government bonds become a more attractive investment, and therefore divert money away from other investments. Higher interest rates can therefore result in less money flowing into the stock market, resulting in lower demand for stocks, and lower prices.
In addition, since this relationship is widely known, a broad expectation of future lower price levels forms whenever a broad expectation of future higher interest rates forms. For this reason, we are sure to see a drop in stock market price levels immediately following the rate raise announcement from the Fed. This drop in prices, at least in the short term, will be greater than the true economic effect of rate change, as it will be largely due to money managers attempting to avoid future (expected further) price decline. A self fulfilling prophecy of sorts. This might also be followed by later herd like behavior. That is, the drop in price itself may lead to more people wanting to sell.
The long term effects on market prices will depend on the long term interest rates to follow in the years to come. In the long term, the general weight rising interest rates will have on the market, will be relative to the duration of them rising, as well as the duration of a “high” interest rates environment. That is, the effect of interest rates on price levels is a cumulative one. The more time rates are rising (or not declining) the stronger the effect.
By far the most powerful determinant of stock prices are earnings. Over the past century, stocks have generally traded at around 15 times earnings. Interest rates, once established over a period of a few years, will push this multiple higher or lower. In periods of low interest rates (as we are in right now) stocks may trade at an earnings multiple close to 20. While long periods of high interest rates can push the market downwards to trade at an earnings multiple lower than 15. Earnings do not stay constant over time. Over a short period of a couple years, earnings may decrease significantly or increase significantly. Generally, over the past century, earnings have increased slightly every year, even after allowing for inflation.
To get a broader picture of what can be expected in the US stock market over the next ten to twenty years, lets assume that earnings, overall, will continue to increase slightly at a rate of 2% a year (which is a reasonable to optimistic future). This means earnings will increase by about 20% (in total) in ten years, and by 50% in twenty. If interest rates increase significantly (say to above 8%) over this period, we can assume that stocks will trade at a lower multiple of earnings. If, for example they trade at around 12 times earnings, the market will see trading at price levels about 25% lower than today, ten years from now, and about 10% lower than today twenty years from now.
We can also examine the future possible returns if interest rates rise, but still stay in a “low” range, of about 2-6% over the next twenty years, while still assuming that earnings will grow by 2% every year. If we guess stocks will trade at a multiple of 16 times earnings under these interest rates, then ten years from now stocks will trade at roughly the same prices as they do today. Under these same assumptions stocks will be trading about 20% higher in twenty years, which works out to just under a 1% annual return.
Bottom line: You can safely expect a drop in stock prices to immediately follow the upcoming announcement from the Fed that they are raising their target for the federal funds rate. What will happen afterwards, strongly depends on the Fed’s management of interest rates in the years to come. If stocks are bought at current prices, then even under relatively positive assumptions of consistent increases in corporate earnings as well as relatively low interest rates, returns can be expected to be low over the next ten to twenty years.


APG generates passwords with two (2) to eight (8) random common dictionary words. It displays length and approximate bits of entropy.
4,701
This word list was obtained from Trinity College Department of Computer Science Cryptology Resources Index. Words less than 4 characters in length and contractions have been removed from the list included in APG.
Absolutely. Right-click on the APG app icon and choose Show Package Contents. Browse to Contents > Resources and replace the Words.txt file with your own. Most UNIX distributions, including OS X, have a built-in word list of approximately 250,000 words. That word list can be found here: /usr/share/dict/words.
APG will evaluate the total number of words in the word list (x) and then evaluate log2(x). The calculation is simply the number of words (n) * log2(x), taking into account the use of any separators.
APG uses the newer arc4random() function as opposed to rand() or random(). This function is self-seeding and uses a superior algorithm.


--- date: 2016-11-11 tags: - fun author: jamworld layout: post title: Interesting Economic Theory excerpt: Useless Inter galaxy theory categories: - fun ---
paper


{% include 'head.html' %} Mflix A movie experience You must log into an account to view this content. Sign Up Log In


In Scientilla, you can view, add and certify your scientific production to provide information that is always checked and verified.
Scientilla suggests to you the documents that are likely to belong to your scientific production, that you can add to your Verified section with a few clicks.
Please, follow the few next steps to set up your profile and start to add your documents!


Building the TMW Shelter Christmas Tree
The brief
Christmas is about many things; overindulgences, family arguments, and thoughtless gifts, but among the better aspects are the general gestures of goodwill and decorations to put even Santas grotto to shame. So, what project could be better than a digital Christmas tree that raised money for the charity Shelter?
The initial concept, thought up by Marlen Lutter, was simple; decorate a tree and raise money for Shelter. The key to this was to incentivise people to donate money, and we wanted to reward them for donating. Now the heart of any good tree is the set of lights it bears (and not, I’m told, tinsel) so naturally a tree that is slowly lit by donations was the obvious choice, and a great starting point. Of course, we couldn’t just stop there, we wanted the tree to be more impressive and give feedback to the lovely people donating, so we threw in an LED matrix display, of the kind you see on trains and buses.
The build
Working through the general ideas we realised there was one issue that needed addressing: what donation should trigger a single light on the tree, and how would we keep track of the total donations?
For the first, we decided that a donation of £1 should be the trigger, and Andrew Williams did some very clever work with that. First, he modelled a bespoke coin chute and pivot trigger that could depress a small switch used later in the circuitry, and then fine-tuned that with weights on the trigger so that only the weight of a £1 coin would set it off. This was especially important, as there are other coins that will fit into a slot that size, and we wanted an automated way to calculate the donations.
My part in the build was to get the lights working in conjunction with the matrix display and the trigger switch, using an Arduino. I first built code around the LED display, making a simple loop that allowed for varying messages to be triggered from either a donation, or as a random message to show when the tree wasn’t being interacted with.
Getting this far highlighted another problem: what if the Arduino lost power or had to be cycled during the time the tree was up? It would need to have a way to save and read the current total of donations it had taken, so we thought the best way for that was via an ethernet shield connected to the network. A couple of PHP scripts and a database later, and it was capable of saving and reading the totals, and it also allowed me to be remotely appraised of the trees progress.
Once that was completed, I had to integrate the lights (quite an important part of a Christmas tree!), and Andrew again helped out with some code for this using a sample he’d written to interact with them. The lights themselves were a strip of 150 RGB LEDs that could be individually coloured and switched on, perfect for the job at hand as it let us light the tree exactly the colour we wanted. I even added a little flashing light effect to the LED that was lit as a result of the donation which flashed only as long as the Arduino was awaiting a response back from the network after recording a new donation.
The final result
Once the pieces were finally assembled the tree was turned on and everything was working. We made one final amendment to the flashing LED effect to make it stand out more by having the entire set flash, which was much more visually appealing. A little Christmas tune wouldn’t have gone amiss here as a wonderful accompaniment to the light show, and this is certainly on somebody’s list next year. The project was developed with the future in mind, and we hope to turn this into a TMW tradition for every year.
In total we raised £109 for Shelter, and built something that was a challenging but brilliant union of physical and digital. I learnt a lot in the process, not least of which about how to correctly decorate a Christmas tree (with all that technical component integration being a close second!), and feel we definitely embraced the spirit of Christmas, showing that we really do give a damn.
Here are some breakdowns of the data we collected from the total donations:
-Donations by Hour Some peaks over breakfast and lunch
-Donations by Day


Tables
# Default Table
You don't need to add any class name to default table.
| # | City | Country | Population |
|---|---|---|---|
| 1 | Warsaw | Poland | 1,732,707 |
| 2 | Berlin | Germany | 3,562,166 |
| 3 | London | United Kingdom | 8,416,535 |
# Bordered table
| # | City | Country | Population |
|---|---|---|---|
| 1 | Warsaw | Poland | 1,732,707 |
| 2 | Berlin | Germany | 3,562,166 |
| 3 | London | United Kingdom | 8,416,535 |
# Natural wide bordered table
| # | City | Country | Population |
|---|---|---|---|
| 1 | Warsaw | Poland | 1,732,707 |
| 2 | Berlin | Germany | 3,562,166 |
| 3 | London | United Kingdom | 8,416,535 |
# Striped table
| # | City | Country | Population |
|---|---|---|---|
| 1 | Warsaw | Poland | 1,732,707 |
| 2 | Berlin | Germany | 3,562,166 |
| 3 | London | United Kingdom | 8,416,535 |
# RWD table on $mobile
devices
| # | City | Country | Population |
|---|---|---|---|
| 1 | Warsaw | Poland | 1,732,707 |
| 2 | Berlin | Germany | 3,562,166 |
| 3 | London | United Kingdom | 8,416,535 |
# CSS driven table
By default CSS table inherit width of cells from grid columns, use .table--auto-size
class to set automatic width of cell based on cell content.
#
City
Country
Population
1
Warsaw
Poland
1,732,707
2
Berlin
Germany
3,562,166
3
London
United Kingdom
8,416,535
# Clean table
You can use clsss .table--clean
to remove default padding and borders.
If you need simple css driven table without grid, you can omit grid columns classes and use simple div
as col.
#
City
Country
Population
1
Warsaw
Poland
1,732,707
2
Berlin
Germany
3,562,166
3
London
United Kingdom
8,416,535


Archive 2020 [OWASP-MSTG] Crackmes - Uncrackable level 1 Write-up September 10, 2020 [Android] Frida 사용 및 Hooking 방법 September 9, 2020 [VMware Connection failed] VMware SSH 연결 오류 - ip 구성이 올바르지 않습니다 September 1, 2020 [SSH SOCKET ERROR] SSH Socket error Event: 32 Error: 10053 August 10, 2020 [iOS] iPhone 탈옥에서 순정 상태로 되돌리기 June 25, 2020 [Jekyll] Syntax Highlighting with rouge June 16, 2020 [BurpSuite] A JNI error has occurred / A Java Exception has occurred 오류 June 10, 2020 [Android] 안드로이드 Burp Suite 사용 설정 June 8, 2020 [Code-Server] 웹 브라우저로 원격 서버에 접속 해 개발하기 (feat. VSCode) May 13, 2020 [Apache Tomcat] 서버 버전 정보 노출 숨기기 April 5, 2020 [Apache2] 서버 버전 정보 노출 숨기기 April 5, 2020 [AWS S3] Referer를 통해 S3 파일 접근 제어하기 April 5, 2020 [Secure Coding] SonarQube 설치 및 사용법 March 29, 2020 [Vmware] EFI Network / Timeout Error March 20, 2020 [AWS S3] AWS CLI로 S3 파일 업로드 및 다운로드 하기 March 7, 2020 [Spring 게시판 만들기] Spring 개발 환경 구축하기 February 18, 2020 [Web] Secure 및 HttpOnly 쿠키 옵션 February 4, 2020 [Python 오류] command errored out with exit status 1 python setup.py egg_info 오류 January 20, 2020 [Docker] Docker 명령어 January 19, 2020 [Database-DB2] 새로운 User 생성 및 권한 부여하기 January 7, 2020 [Database-DB2] DB2 Query 정리 January 6, 2020 [Jekyll] Local에 Github Blog 세팅하기 January 6, 2020 [Database-DB2] Docker로 IBM DB2 설치하기 January 5, 2020 [iOS] SSH 및 SFTP 사용하기 January 2, 2020 [iOS] 어플리케이션 Decrypt 및 분석 January 2, 2020 2019 [Frida 오류] Frida - Failed to load the Frida native extension December 15, 2019 [iOS] 아이폰 BurpSuite 및 Frida 사용 세팅하기 December 12, 2019 [iOS] 3uTools 통해 12.1.4 탈옥하기(Without ignition, impactor) December 10, 2019 [iOS] 아이폰 초기화 하기(iTunes 없이 / iOS 업데이트 없이) December 10, 2019 [POXX2019-Quals] magic2 / Clue Write up October 15, 2019 [CCE2019] hwp Write up October 15, 2019 [Lord of SQL Injection] LoS - incubus 문제풀이 August 7, 2019 [Lord of SQL Injection] LoS - siren 문제풀이 August 6, 2019 [Lord of SQL Injection] LoS - cerberus 문제풀이 August 5, 2019 [Lord of SQL Injection] LoS - kraken 문제풀이 August 4, 2019 [Lord of SQL Injection] LoS - mummy 문제풀이 August 3, 2019 [Lord of SQL Injection] LoS - yeti 문제풀이 July 29, 2019 [Lord of SQL Injection] LoS - revenant 문제풀이 July 27, 2019 [Lord of SQL Injection] LoS - nessie 문제풀이 July 5, 2019 [Lord of SQL Injection] LoS - poltergeist 문제풀이 July 4, 2019 [Lord of SQL Injection] LoS - banshee 문제풀이 July 3, 2019 [Lord of SQL Injection] LoS - manticore 문제풀이 June 19, 2019 [Lord of SQL Injection] LoS - chupacabra 문제풀이 June 18, 2019 [Lord of SQL Injection] LoS - cyclops 문제풀이 June 17, 2019 [Lord of SQL Injection] LoS - godzilla 문제풀이 June 14, 2019 [Lord of SQL Injection] LoS - death 문제풀이 June 13, 2019 [Lord of SQL Injection] LoS - cthulhu 문제풀이 June 12, 2019 [DEFCON 2019 Quals] cant_even_unplug_it Write-up May 18, 2019 [Android] 안드로이드 어플리케이션 디컴파일 및 리패키징 April 21, 2019 [VolgaCTF2019] Shadow Cat Write up April 8, 2019 Javascript 난독화 기법 March 10, 2019 [Pwnable.kr] Toddler's Bottle - lotto 문제풀이 February 14, 2019 [Pwnable.kr] Toddler's Bottle - shellshock 문제풀이 February 13, 2019 [Pwnable.kr] Toddler's Bottle - cmd2 문제풀이 February 12, 2019 [Pwnable.kr] Toddler's Bottle - cmd1 문제풀이 February 11, 2019 [Wargame.kr] DB is really GOOD 문제풀이 February 8, 2019 [Insomni'hack 2019] l33t-hoster Write up(미완성) January 24, 2019 2018 [35C3 CTF 2018] php Write up December 30, 2018 [TenDollar 2018] Ping! Ping! Ping! Write up December 16, 2018 [RITSEC 2018] What a cute dog! Write up November 19, 2018 [Linux 오류] Cannot find device ens33 November 18, 2018 [POXX2018-Final] Groot / 2+3 / WHATISTHIS Write up November 15, 2018 [Wargame.kr] md5 password 문제풀이 October 26, 2018 [Wargame.kr] fly to the moon 문제풀이 October 25, 2018 [Wargame.kr] WTF_CODE 문제풀이 October 24, 2018 [Wargame.kr] login filtering 문제풀이 October 23, 2018 [Wargame.kr] QR CODE PUZZLE 문제풀이 October 17, 2018 [Wargame.kr] flee button 문제풀이 October 16, 2018 [Wargame.kr] already got 문제풀이 October 15, 2018 [hackover 2018] i-love-heddha Write up October 7, 2018 [Chrome] Chrome Headless 사용법 September 29, 2018 [Lord of SQL Injection] LoS - alien 문제풀이 September 19, 2018 [Lord of SQL Injection] LoS - zombie 문제풀이 September 18, 2018 [Lord of SQL Injection] LoS - ouroboros 문제풀이 September 17, 2018 [Lord of SQL Injection] LoS - phantom 문제풀이 September 16, 2018 [Lord of SQL Injection] LoS - frankenstein 문제풀이 September 14, 2018 [Lord of SQL Injection] LoS - blue_dragon 문제풀이 September 9, 2018 [Lord of SQL Injection] LoS - red_dragon 문제풀이 September 8, 2018 [Pwnable.kr] Toddler's Bottle - blukat 문제풀이 August 25, 2018 [Lord of SQL Injection] LoS - green_dragon 문제풀이 August 25, 2018 [Lord of SQL Injection : eagle-jump] LoS - umaru 문제풀이 August 24, 2018 [Lord of SQL Injection] LoS - evil_wizard 문제풀이 August 24, 2018 [Lord of SQL Injection] LoS - hell_fire 문제풀이 August 23, 2018 [Lord of SQL Injection] LoS - dark_eyes 문제풀이 August 22, 2018 [Lord of SQL Injection] LoS - iron_golem 문제풀이 August 16, 2018 [Lord of SQL Injection] LoS - dragon 문제풀이 August 15, 2018 [Lord of SQL Injection] LoS - xavis 문제풀이 August 14, 2018 [Lord of SQL Injection] LoS - nightmare 문제풀이 August 6, 2018 [Lord of SQL Injection] LoS - succubus 문제풀이 August 5, 2018 [Lord of SQL Injection] LoS - zombie_assassin 문제풀이 August 4, 2018 [Lord of SQL Injection] LoS - assassin 문제풀이 August 3, 2018 [Lord of SQL Injection] LoS - giant 문제풀이 August 2, 2018 [Lord of SQL Injection] LoS - bugbear 문제풀이 August 1, 2018 [Lord of SQL Injection] LoS - darkknight 문제풀이 July 31, 2018 [ISITDTU 2018] Friss Write up July 31, 2018 [Lord of SQL Injection] LoS - golem 문제풀이 July 30, 2018 [Lord of SQL Injection] LoS - skeleton 문제풀이 July 29, 2018 [ISITDTU 2018] IZ Write up July 29, 2018 [Lord of SQL Injection] LoS - vampire 문제풀이 July 28, 2018 [Lord of SQL Injection] LoS - troll 문제풀이 July 27, 2018 [Lord of SQL Injection] LoS - orge 문제풀이 July 26, 2018 [Lord of SQL Injection] LoS - darkelf 문제풀이 July 25, 2018 [Lord of SQL Injection] LoS - wolfman 문제풀이 July 24, 2018 [Lord of SQL Injection] LoS - orc 문제풀이 July 23, 2018 [Lord of SQL Injection] LoS - goblin 문제풀이 July 22, 2018 [Lord of SQL Injection] LoS - cobolt 문제풀이 July 21, 2018 [Lord of SQL Injection] LoS - gremlin 문제풀이 July 20, 2018 [MeePwn2018] OMEGASECTOR Write up July 18, 2018 [MeePwn2018] WHITE SNOW, BLACK SHADOW / ESOR / EZCHALLZ Write up July 17, 2018 [XSS Game] Write up June 27, 2018 [Pwnable.kr] Toddler's Bottle - mistake 문제풀이 May 30, 2018 [Pwnable.kr] Toddler's Bottle - random 문제풀이 May 29, 2018 [RCTF2018] rblog Write up May 27, 2018 [RCTF2018] amp Write up May 23, 2018 [Linux 오류] Could not get lock 오류 April 23, 2018 [Pwnable.kr] Toddler's Bottle - flag 문제풀이 February 21, 2018 [Pwnable.kr] Toddler's Bottle - bof 문제풀이 February 19, 2018 [Pwnable.kr] Toddler's Bottle - col 문제풀이 February 17, 2018 [Pwnable.kr] Toddler's Bottle - fd 문제풀이 February 15, 2018 [Linux] 소유권(Ownership) / 허가권(Permission) February 15, 2018


Lorem ipsum dolor sit amet, consectetur adipisicing elit With supporting text below as a natural lead-in
Lorem ipsum dolor sit amet, consectetur adipisicing elit
Some quick example text to build on the card title and make up the content.
Some quick example text to build on the card title and make up the content.
Some quick example text to build on the card title and make up the content.


Software Engineer
I am a software engineer specialising in high availability, high throughput data pipelines. Experienced in the telco space, both from a data perspective and a network perspective. A great team player, with communication skills amplifying technical knowledge to add significant value to development teams. A relentless tinkerer, I love to automate things, whether it’s business processes, programming and design tools, or the technology in my home. I am also a strong believer in continuous self-education, with a stack of books normally on the go - currently working through Structure and Interpretation of Computer Programs. Resume is available here


Edwards, Lilly May
| Birth Name | Edwards, Lilly May |
| Gender | female |
| Age at Death | unknown |
Narrative
Lily May's death says she is the daughter of Alfred & Agnes Catherine Edwards. I haven't been able to find a birth.
SMH - Lily May NEWLING - 6 October, 1966, at hospital, of 6 Hannah St, Westmead, dear wife of late Joseph Newling, loved mother of Arthur(dec), Eileen, Raymond, Leslie & Jean, aged 86 years.
The rels & friends of late Lily May Newling are invited to her Funeral, to leave St. John's Church, Parramatta, this morning after a service at 9.40am, for Western Rd Cemetery, Parramatta.
Events
| Event | Date | Place | Description | Sources |
|---|---|---|---|---|
| Birth | c1880 | |||
|
|
||||
| Death | 1966-10-06 | at hospital late of Westmead NSW #37383 | ||
|
|
||||
| Burial | 1966-10-09 | Mays Hill Baptist Cemetery Parramatta | ||
|
|
Families
Family of Newling, Joseph Randolph and Edwards, Lilly May |
|||||||||||||||||||||||||||||
| Married | Husband | Newling, Joseph Randolph ( * 1873 + 1944-06-24 ) | |||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||
| Children |
| Name | Birth Date | Death Date |
|---|---|---|
| Newling, Elaine A. M. | 1897 | 1897 |
| Newling, Vera F. | 1899 | 1900 |
| Newling, Arthur Ernest | 1901 | 1960-11-01 |
| Newling, Myra Eileen | 1905 | |
| Newling, Raymond Spencer | 1908 | 1978-07-14 |
| Newling, Albert L:eslie Randolph | 1978 | |
| Newling, Jean Emmeline | c1918 | |
| Newling, Eileen Vera |
| Type | Value | Notes | Sources |
|---|---|---|---|
| _UID | 0181D746FF949D4E96B0D2E07C4BBFE88322 |
Attributes
| Type | Value | Notes | Sources |
|---|---|---|---|
| _UID | 23F36F33A5BF294DAF1AEE25228C492B90BA |


HP:
Score:100
Hunter!!
Try your best to defeat all monsters!!
HP:
Score:100
Try your best to defeat all monsters!!
1. Select hunting areas to start. Different areas mean different levels.
2. Click the black monster icon to find out the hidden monster.
3. Each turn you can select 2 monsters. If the two monsters are the same, you defeat them and gain points.
4. If they are different monsters, you will get hurt and lose Health Point.
WIN: Find out all matching monsters and make as few mistakes as possible.
LOSE: Health Point reach 0%.


HtmlEncode.js converts non-Ascii characters (>128) to html entities. For xml use numeric entities.
cEncode.js doubles up quotes in a string (useful for all programming languages). The encode method does not put the enclosing quotes around. The encodeLiteral method (specifically for C @literal strings) does put an enclosing double quote around.


Place an Order Message Congratulations! Happy Birthday! Happy Anniversary! I Love You! Custom Message: Billing Address First Name Last Name Street Address City State Zip Phone Delivery Address same as billing address First Name Last Name Street Address City State Zip Phone Delivery Date 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 2015 2016 2017 Payment Visa MasterCard Discover American Express Card # Expiration 2015 2016 2017 CVV Create Account? To be able to access your purchase history and make changes to your order, enter a name and password to create an account. Username Password Password (Verify)


Yes, it was great to listen to Shereef's talk about the DBC experiment. We all want to do our best to create great dishes from the Kitchen rather than just ordering from the Restaurant menu.
I hope that the Tortoise vs Hare analogy proves true for me at DBC :). I feel way behind already and hope that if I keep plucking away I will succeed. Looking forward to meeting everyone and doing my best to be a good citizen of the DBC community.


UI/UX Designer, Asset Creation, Iconography, Photography, Photo Editing, Brand and Media Specialist
Hak Studio, Remote
2014 - 2015
Project documents for township website redesigns.
While the team was building websites, I was tasked with iconography and graphic design for our clients.
<EMAIL_ADDRESS>EMAIL DRIBBBLE LINKEDIN RESUME
Back to Top


{% extends "base_side_categories.html" %} {% block title %}{{ _('Not Found') }}{% endblock %} {% block content %} {% trans rec=url('browse.extensions')|urlparams(sort='featured'), search=url('search.search'), home=url('home'), open_bug_link=''|safe, close_bug_link=''|safe %}
The page or file you requested wasn't found on our site. It's possible that you clicked a link that's out of date, or typed in the address incorrectly.
Or you can just jump over to some of the popular pages on our website.


|
lwIP
2.1.3
Lightweight IP stack
|
Functions | |
| u8_t | tcp_ext_arg_alloc_id (void) |
| void | tcp_ext_arg_set_callbacks (struct tcp_pcb *pcb, uint8_t id, const struct tcp_ext_arg_callbacks *const callbacks) |
| void | tcp_ext_arg_set (struct tcp_pcb *pcb, uint8_t id, void *arg) |
| void * | tcp_ext_arg_get (const struct tcp_pcb *pcb, uint8_t id) |
Additional data storage per tcp pcb
When LWIP_TCP_PCB_NUM_EXT_ARGS is > 0, every tcp pcb (including listen pcb) includes a number of additional argument entries in an array.
To support memory management, in addition to a 'void *', callbacks can be provided to manage transition from listening pcbs to connections and to deallocate memory when a pcb is deallocated (see struct tcp_ext_arg_callbacks).
After allocating this index, use tcp_ext_arg_set and tcp_ext_arg_get to store and load arguments from this index for a given pcb.
| u8_t tcp_ext_arg_alloc_id | ( | void | ) |
Allocate an index to store data in ext_args member of struct tcp_pcb. Returned value is an index in mentioned array. The index is global over all pcbs!
When LWIP_TCP_PCB_NUM_EXT_ARGS is > 0, every tcp pcb (including listen pcb) includes a number of additional argument entries in an array.
To support memory management, in addition to a 'void *', callbacks can be provided to manage transition from listening pcbs to connections and to deallocate memory when a pcb is deallocated (see struct tcp_ext_arg_callbacks).
After allocating this index, use tcp_ext_arg_set and tcp_ext_arg_get to store and load arguments from this index for a given pcb.
| void* tcp_ext_arg_get | ( | const struct tcp_pcb * | pcb, |
| uint8_t | id | ||
| ) |
Set data for a given index of ext_args on the specified pcb.
| pcb | tcp_pcb for which to set the data |
| id | ext_args index to set (allocated via tcp_ext_arg_alloc_id) |
| void tcp_ext_arg_set | ( | struct tcp_pcb * | pcb, |
| uint8_t | id, | ||
| void * | arg | ||
| ) |
Set data for a given index of ext_args on the specified pcb.
| pcb | tcp_pcb for which to set the data |
| id | ext_args index to set (allocated via tcp_ext_arg_alloc_id) |
| arg | data pointer to set |
| void tcp_ext_arg_set_callbacks | ( | struct tcp_pcb * | pcb, |
| uint8_t | id, | ||
| const struct tcp_ext_arg_callbacks *const | callbacks | ||
| ) |
Set callbacks for a given index of ext_args on the specified pcb.
| pcb | tcp_pcb for which to set the callback |
| id | ext_args index to set (allocated via tcp_ext_arg_alloc_id) |
| callbacks | callback table (const since it is referenced, not copied!) |


InstantConverter()
Converts from a Instant to a java.sql.Timestamp for Java 8. Note that when converting between the time type and the database type all times will be converted to the UTC zone offset.


procedural graphics in your browser
Manual
brought to you by
@Kastor_
and
@rattazong
| powered by
THREE.js
Save
Open
Export to .PNG
Load Sample
Use
Space
to set observed operation for rendering
Use
Shift+Click
to set additional operation parameters


--- layout: default title: "404: Page not found" permalink: 404.html ---
Oops, looks like something went wrong. Sorry about that! If you come across this message, I would appreciate it if you would let me know. Click here to head back home.


About
Getting information is the smartest work an human being does.Here you are,you will find all finace related blogs,corporate and infletion news in the finance sector &beneficial app and websites for asset management/SIP insurence/mutual funds/portfolio management. We will provide you the best websites and app financial service in India. We are the non profit organistion so you can trust us and be tension free about endosing your capital in one the provided finance corporate companies.
Analytics
Knowing the analytics is the challenge faced by every in the beginning . Here we are with the modern solution with latest technology to help you with.we provide you the tested and worthful top listed softwares based on the experience of the market experts and many users. These analytics tracing software will give you the best experience to read and study the market which will definetly going to make your “wealth grow”
Calculation and Auditing
Calculating & auditing is most compex part for an beginner or the person having no kowladge or no experience, isn’t it!! We will provide you the list of best and assured softwares which will make your calculation and auditing part easy . Now you can do your other work not worrieng about the “wealth calculation and auditing”.
Management
Managing your fund and portfolio is an critical task of invester .Without the proper knowledge ypu can’t deal wit it. Back in then we is to meet the fund manager or portfolio manager physically. Which is a very hectic task do and it also waste your priceless “time”. Here you will find list best fund manager and portfolio maneger. The apps and website provided on the listed is engaged with some finest fund & portfolio manager , even the best AI and prediction technologies is used by them. Which will make your “Wealth grow”.
Finance your own world @ 2020 copyright
Founder
Sounak saha
contact web Developer : service @ webdeveloper
Contact Web developer :8335086685
For any suggestion : financeyourownworld.co @ gmail.com
call us :9330406342


User is not managing any Client Apps. Perhaps that's just not her thing. But if it is, she can create a new Client App using the New Client App button above.
No Client Apps found matching your filter criteria - please try searching for something different.


The Turtle Mobile
The Turtle Mobile was our very first, worst and unrealistic idea. It should be a kind of car, which could not just drive, but fly and swim too.
We're sorry to tell we have stopped working on this project.
The Turtle Mobile was our very first, worst and unrealistic idea. It should be a kind of car, which could not just drive, but fly and swim too.
We're sorry to tell we have stopped working on this project.


Since 1881, NJIT has been committed to academic excellence. As one of the nation’s leading polytechnic universities, NJIT provides students with the edge they need to be leaders in today’s competitive high-tech marketplace.
With superior academic programs, expert faculty, exceptional research opportunities and hundreds of internship and cooperative education opportunities, NJIT prepares you for your future.
If you have less than 15 college credits and have never attended another college or university.
If you have at least 15 college credits from another college or university.
If you have attended NJIT for at least one semester, but then took at least one semester off.
NJIT welcomes visiting students who currently are or used to be enrolled at other colleges/universities.
Pursue a master's or doctoral degree to advance your career or remain competitive by earning a certificate in your field.
“I have enjoyed my time in the Materials Science and Engineering Program, particularly the small classes and individual attention that help in hands-on learning.”
“I am thankful to NJIT for my scholarship and for the doors that the APPH program has opened for me.”
“I have enjoyed my time in the Materials Science and Engineering Program, particularly the small classes and individual attention that help in hands-on learning. I am grateful for my journey at NJIT. Taking it ahead now.”


Mike Matcke
Technical PM, CSM, Jack of all Trades
If you are interested in working together, collaborating or have questions about my work, please reach out to me by using the form below!
Make sure to state which service you are interested in, for example, "Videography work"
or "Develop a website." I will return your message as soon as I can!
Thank you for visiting my site and taking a look at my work! All the best- Mike.


2. Hero
2.1 Hero Feature
2.2 Hero Call to Action
3. Ad
4. Body
4.1 Article Feature
4.2 Article Listing
3. Ad


Brooke Kemp and Brynn Mechem // Story
Stephanie Amador // Photography
Michael Himes // Development and Design
Brooke Kemp and Brynn Mechem // Story
Stephanie Amador // Photography
Michael Himes // Design and Development
While eager freshmen wheel suitcases and lug furniture up to their new home for the semester, it’s not uncommon to picture what the future may hold for them at Ball State.
It would be hard, however, to grasp the university’s past — what it took to mold what was once a donation from the Ball brothers into the university students know today.
In fact, not even the name of the university was the same when June Yates attended Ball State.
World War II was coming to a close as Yates began her first semester at Ball State Teachers College in 1944. At the time, most men were finishing their tours of duty, making women the majority of the student population.
Before the men returned, Yates lived in Elliott Hall with one roommate. On the top floor of the residence hall was an open space for aspiring nurses being fast-tracked through the program to provide quick aid to those still fighting the war.
“I was 18, they put me with a girl who was 23. I thought, ‘Why are they putting me with an old lady?’ But, we became best friends,” Yates said. “She was a wonderful girl.”
When the soldiers came back to campus, however, a severe increase in enrollment caused a chain reaction of changes across campus.
Yates was moved to Lucina Hall, where she shared a dorm with three other women. Elliott Hall again became an all-men’s dorm.
“When I was a freshman there were about 1,000 girls and about 50 men on campus. The next year, as the war was over, the trend absolutely totally reversed and there were like 10 men to one girl,” Yates said. “Boy is that nice.”
Among the men returning from war was her future husband, Robert. Both June and Robert worked in the dining halls on campus for 35 cents an hour, and met when she was on a date with another student named Jim.
“This was after all the men came back, you know that exciting time?” Yates said. “[Jim] took me to the dish room where [Robert] was working at Elliott Hall and introduced me to my future husband, and I think it was just love at first sight. We just hit it off immediately.”
Yates went to Ball State until 1948 before ultimately marrying Robert that summer. She then opted to take classes in the summer to finish her degree.
Not only did she meet her husband after the war, her class sizes changed. All the buildings her classes were in were squeezed into what is now known as the North Quad, and typically consisted of 25 students, similar to class sizes today. Her coursework, however, would be considered core curriculum for today’s students.
It wasn’t until the mid-60s that the number of colleges and courses offered began to grow, which meant students like Jan Largent, who attended Ball State in the late 50s had to major in education while studying her real passion, accounting.
The campus Yates was familiar with had changed by the time Largent began her studies, however. Students had more places to live, including a building that previously functioned as a military barrack.
While Largent’s degree is in teaching, she focused on accounting and business administration. Because her classes were combined with a teaching major, Largent taught a shorthand class at the Muncie Community Schools as part of her studies.
Largent was the only female in the accounting program at the time. Before she graduating, Largent again found herself among another minority on campus: pregnant students.
“I was single one year, I was married the second year, by the beginning of the third year [my son] was born,” Largent said. “That’s a whole different ball game, trying to stay awake and study and have part time jobs.”
When Largent went into labor, her husband Charlie was in a summer class at Ball State. He intended to go to the hospital during the mid-class break, but instead, the professor taught straight through. By the time he reached the hospital, their son David had been born.
David, who is a 2010 master’s graduate, now teaches computer science at the university. His wife, Lois, who is an administrative coordinator for the department of finance and insurance, is a 1981 graduate.
Before David and Lois attended Ball State, however, Jan returned to school to finish her degree along with Charlie, using non-electric typewriters and a Marchant calculator.
However, her studies weren’t the only time she lacked the luxury of electronics. During her time as an assistant in the Administrative Building, she didn’t have a computer, forcing her to hand-file student information.
“We had these little slips of paper, and it would have the student’s name and the classes they’re taking,” Largent said. “That’s how we kept track of students and their classes; we filed them all alphabetically. There was no computers at all at that point.”
It wasn’t long, however, until students, including David and Lois, were able to utilize technology during their studies.
Lois studied computer science as an undergraduate at Manchester University and later attended Ball State for a specialist in education psychology. David, however, worked a full-time job until 2008 when he decided to pursue a master’s in computer science.
“Obviously I’d been out of school for a long time, so I wondered what it was going to be like as a 50-year-old going into class with 20-somethings,” David said. “But, I discovered that learning is sort of like riding a bike, you pick it back up really quickly and at the time I was surprised, but I was very well recepted by the 20-somethings.”
The married couple attempted to reside in Scheidler Apartments when Lois was gaining her degree in 1980. However, the apartments, which were only for married couples at the time, were completely full.
After graduating, David was immediately hired as a professor at the university after graduating, and has now worked at Ball State for nearly nine years. Teaching at the university has allowed him to watch it transition in a number of ways, but one of the biggest changes he saw was the addition of immersive learning.
This addition took David and his students to England, Ireland and Scotland as part of an immersive learning course. Most recently, he taught a course that was immersed with middle school students at Muncie Community Schools.
“There are just a number of opportunities now that I, or other students wouldn’t have had 10 or 20 years ago,” David said.
David and Lois’ son, Jon, hoped to take this course with his father, however, due to university policy, Jon couldn’t.
Jon did, however, study in the same department his father teaches in upon pursuing his second bachelor’s degree, this time in computer science at Ball State.
 While some classes seemed easier, courses such as calculus proved a bit more difficult than what Jon remembered.
“Coming back at an older age for a second degree allowed me to break out of some of the bad habits I had the first time around,” Jon said. “I talk for a living, so taking COMM 210 was extremely simple, but there were calculus classes where I hadn’t taken math for a decade, and I was trying to remember somewhat complex algebra and I’m like, ‘I got nothing.’”
Despite the difference in class material, Jon earned his second degree, graduating in July and joining his sister and aunt in the list of seven Ball State alumni. Between his two degrees, Jon said he has accumulated upwards of $50,000 in debt, something Jan said wouldn’t have happened in her time.
“I don’t think people ended up in great debt when you graduated,” Jan said. “But probably, if we hadn’t had the money, I would have stopped school, earned the money and come back. That was sort of the lines at the time.”
Even though each of the Largents experienced a different challenge at the university, they all said they enjoyed their time.
“Maybe one day Jacob will attend the university, who knows,” Lois said.
Contact Brooke Kemp with comments at<EMAIL_ADDRESS>or on Twitter @brookemkemp.
Contact Brynn Mechem with comments at<EMAIL_ADDRESS>or on Twitter@BrynnMechem.


Hi! Thank you for contribution to this crowdsourcing project!
In this experiment, you will be provided with a building footprint geometry, which has been generated automatically or is derived from another dataset.
Furthermore, satellite image tiles will be displayed as a background layer.
Your task is to determine whether the building footprint correctly delineates a building also present in the satellite image.
Sounds difficult? Just go through the tutorial, we will show you how to do it!
Your first question will be: How does a correct building footprint look like and what should you watch out for?
The examples show building footprints which are correctly aligned with the buildings in the image. The buildings are not shifted.
Secondly, the shape of the buildings is correct. Most buildings will be rectangular, some might also have a circular shape.
Choose for these cases
Always check first: Does the footprint geometry really represents a building?
Sometimes the proposed building geometry doesn't represents a building. Trees, cars, swimming pools or other similar looking objects are potentially detected as a building. Watch out for these objects as well.
Choose in these cases.
The examples can give you a better feeling how things which are not a building look like.
Please note: Building can be shifted and misaligned.
When looking at the buildings you will notice that some buildings are shifted and misaligned. However, the shape is correct.
Choose in these cases.
The examples can give you a better feeling how this looks like.
And of course: Building might have an incorrect shape.
When looking at the buildings you will notice that some buildings have a unnatural form. However, the alignment is correct.
Choose in these cases.
The examples can give you a better feeling how this looks like.
Misaligned and shifted
Who would have guessed, buildings might have a unnatural form and the alignment is wrong at the same time. However, the footprint still somehow represents a building.
Choose in these cases.
The examples can give you a better feeling how this looks like.
You don't know how to decide?
Sometimes it might be hard to decide, what the problem with the geometry is. Don't worry, it's a difficult task.
Choose in these cases.
The examples can give you a better feeling how this looks like.
Feeling ready to start?
A tutorial is linked in every task, so don`t worry if you need to refresh your knowledge in between ;-)
The images you've seen in this tutorial may not represent the range of images you'll encounter in this survey.
Use your best judgment to complete each question independent of one another.
Have fun!
You are working on task: #
Geometries Validated:
Rank: