To view instances in the Browser
1 Select one or more entities in the Elements or Results column.
2 Select Show Instances in the Ask column.
The instances appear in the Results column.
If you have created a group that contains instances, you can select the group containing them and then select Browse > Model Browser from the main menu. The instances appear in the Browser’s Elements column.


This page provides debugging information about assets injected into the HTML page for the current request:
{{currentUri}}
See below in a graph view what bundles are included in the current request
See below in a tabular view what assets Dandelion injects into the current page
| Bundle | Asset | Type | Version | Action |
|---|---|---|---|---|
| {{bundle}} | {{name}} | {{type}} | {{version}} | View asset |
See below how Dandelion injects assets into the current page
<html> <head> ... {{#assetsInHead}} <link href="{{{.}}}"></link> {{/assetsInHead}} </head> <body> ... {{#assetsInBody}} <script src="{{{.}}}"></script> {{/assetsInBody}} </body> </html>


DevOpsDays Ohio is a local event under the umbrella of DevOpsDays, a worldwide series of technical conferences covering topics of software development, IT infrastructure operations, and the intersection between them.
Our goal is to provide two days of amazing presentations and learning experience for anyone and everyone!
You will be able to sign up soon! We will keep you updated.
Absolutely! Checkout this page for more information on the types of presentations and how to submit.
All details, schedules, presenters and abstracts are available on the primary information website


A data flow graph representing a TensorFlow computation.
Instances of a Graph are thread-safe.
WARNING: Resources consumed by the Graph object must be explicitly freed by invoking
the close()
method then the Graph object is no longer needed.
|
Graph()
Create an empty Graph.
|
| Output[]<?> |
addGradients(String prefix, Output[]<?> y, Output[]<?> x, Output[]<?> dx)
Adds operations to compute the partial derivatives of sum of
y s w.r.t x s, i.e.,
d(y_1 + y_2 + ...)/dx_1, d(y_1 + y_2 + ...)/dx_2...
|
| Output[]<?> |
addGradients(Output<?> y, Output[]<?> x)
Adds operations to compute the partial derivatives of sum of
y s w.r.t x s,
i.e., dy/dx_1, dy/dx_2...
This is a simplified version of {@link #addGradients(Output[], Output[], Output[]) where {@code y} is a single output, {@code dx} is null and {@code prefix} is null. |
| void |
close()
Release resources associated with the Graph.
|
| void |
importGraphDef(byte[] graphDef, String prefix)
Import a serialized representation of a TensorFlow graph.
|
| void |
importGraphDef(byte[] graphDef)
Import a serialized representation of a TensorFlow graph.
|
| OperationBuilder | |
| Operation |
operation(String name)
Returns the operation (node in the Graph) with the provided name.
|
| Iterator<Operation> |
operations()
Iterator over all the
Operation s in the graph. |
| byte[] |
toGraphDef()
Generate a serialized representation of the Graph.
|
Create an empty Graph.
Adds operations to compute the partial derivatives of sum of y
s w.r.t x
s, i.e.,
d(y_1 + y_2 + ...)/dx_1, d(y_1 + y_2 + ...)/dx_2...
dx
are used as initial gradients (which represent the symbolic partial derivatives
of some loss function L
w.r.t. y
). dx
must be null or have size of
y
.
If dx
is null, the implementation will use dx of ERROR(OnesLike/org.tensorflow.op.core.OnesLike OnesLike)
for all shapes in y
.
prefix
is used as the name prefix applied to all nodes added to the graph to compute
gradients. It must be unique within the provided graph or the operation will fail.
If prefix
is null, then one will be chosen automatically.
| prefix | unique string prefix applied before the names of nodes added to the graph to compute gradients. If null, a default one will be chosen. |
|---|---|
| y | output of the function to derive |
| x | inputs of the function for which partial derivatives are computed |
| dx | if not null, the partial derivatives of some loss function L w.r.t. y |
dy
with the size of x
Adds operations to compute the partial derivatives of sum of y
s w.r.t x
s,
i.e., dy/dx_1, dy/dx_2...
This is a simplified version of {@link #addGradients(Output[], Output[], Output[]) where {@code y} is a single output, {@code dx} is null and {@code prefix} is null.
| y | output of the function to derive |
|---|---|
| x | inputs of the function for which partial derivatives are computed |
dy
with the size of x
Release resources associated with the Graph.
Blocks until there are no active Session
instances referring to this Graph. A Graph
is not usable after close returns.
Import a serialized representation of a TensorFlow graph.
| graphDef | the serialized representation of a TensorFlow graph. |
|---|---|
| prefix | a prefix that will be prepended to names in graphDef |
| IllegalArgumentException | if graphDef is not a recognized serialization of a graph. |
|---|
Import a serialized representation of a TensorFlow graph.
The serialized representation of the graph, often referred to as a GraphDef, can be
generated by toGraphDef()
and equivalents in other language APIs.
| graphDef |
|---|
| IllegalArgumentException | if graphDef is not a recognized serialization of a graph. |
|---|
Returns a builder to add Operation
s to the Graph.
| type | of the Operation (i.e., identifies the computation to be performed) |
|---|---|
| name | to refer to the created Operation in the graph. |
OperationBuilder
, which will add the Operation to the graph when build()
is invoked. If build()
is not invoked,
then some resources may leak.
Returns the operation (node in the Graph) with the provided name.
Or null
if no such operation exists in the Graph.
| name |
|---|
Iterator over all the Operation
s in the graph.
The order of iteration is unspecified. Consumers of the iterator will receive no notification should the underlying graph change during iteration.
Generate a serialized representation of the Graph.


{% extends 'base.html'%} {% import 'bootstrap/wtf.html' as wtf %} {% block styles%} {{super()}} {% endblock%} {% block content %}
Email Adress: {{user.email}}
About Me: {{user.bio}}
{{pitch.pitch}}
Posted On: {{pitch.posted.strftime('%Y-%m-%d')}}Likes: {{pitch.upvotes}} Dislikes: {{pitch.downvotes}}


Vanya is the proud cofounder and copresident of Design.it! She started learning HTML and CSS in 8th grade, and moved on to JavaScript her freshman year. She has built many personal websites and has also released her first iPhone app, Wander, on the iTunes App Store. Her favorite thing to do on weekends is go to hackathons and build cool stuff. She is so excited to share her skills with Design.it club members!
Emily is excited to serve as Design.It's copresident for the 2017-2018 school year. She started learning about web development her sophomore year and became more serious about it junior year, taking her skills to hackathons. She is marveled by the impact technology has on society and wants to be a part of the community that builds it. Aside from coding, Emily loves sewing, watching K-dramas, and drinking boba (maybe everyday).
Christina is a senior this year and is elated to be your Vice President. She enjoys messing around with code to make things match an aesthetic so this club is the ideal creative outlet for her. She enjoys writing custom themes for blogs using HTML and CSS and she has had a little experience with C++ via her robotics team. Art, film, literature, and astronomy hold special places in her heart. She hopes that everyone in this club will have a webpage they're proud of by the end of the year :)
Neha, the treasurer of Design.it, is a senior at Irvington. She began learning how to code for fun during her junior year and fell in love with it. Ever since, she’s learned how to code in programming languages such as Python and C++. In her opinion, coding is simply finding the fastest and most efficient way to solve an actual problem. Although some may be put off by the task of debugging their code, Neha believes that the satisfaction of having a working program makes up for all of the frustration. Besides coding, Neha enjoys listening to music, singing, hiking, and spending time with her friends.
Annika is the secretary of the Design.it club and the IHS Girls in STEM club. Influenced by her father, who tells her about the fascinating technological projects he works on, she develops a curiosity in STEM related subjects. She likes to code (occasionally), and daydreams (all the time).
Coco Yeung is a senior in Irvington High School. She is passionate about art and design. She loves different kinds of art like drawing, painting, photography, and graphic designs. Coco always looks for new kinds of creativity, so she joined the club to try something new and fascinating. She has been told about programming since she was young from her father, but she never had a chance to try it. This club gives Coco a chance to explore the wonders of programming, and benefits her future career. Being the publicist of the club, Coco can combine graphic design and programming together. She will create artistic posters and use social media to publicize the club in order to get people acquainted with programming.


Lexer Error: {0} at column{1} in expression [{2}].
Occurs when an expression has a lexical error, for example a malformed number (0.5e-) or an invalid unicode escape.
The error message contains a more precise error.
To resolve, learn more about AngularJS expressions, identify the error and fix the expression's syntax.


Before Change
A list of sample.Sample instances.
vms = benchmark_spec.vms
loaders = _GetVMsByRole(vms)["loaders"]
aerospike_vms = _GetVMsByRole(vms)["aerospike_vms"]
logging.debug("Loaders: %s", loaders)
vms = benchmark_spec.vms
After Change
A list of sample.Sample instances.
loaders = benchmark_spec.vm_groups["clients"]
aerospike_vms = benchmark_spec.vm_groups["workers"]
executor = ycsb.YCSBExecutor("aerospike",
**{"as.host": aerospike_vms[0].internal_ip,
"as.namespace": "test"})


Struck nostalgia gold digging through old records. These drawings are the layout for my rogue-like game that I implemented with a language called Clipper for the DOS database system dBase III.
3/12/2018, 7:50:42 PM
Favs: 11
Retweets: 0
link--- layout: tweet ---
Struck nostalgia gold digging through old records. These drawings are the layout for my rogue-like game that I implemented with a language called Clipper for the DOS database system dBase III.
3/12/2018, 7:50:42 PM
Favs: 11
Retweets: 0
linkOf course everything was stored in tables because we're running the game in a database anyway! Here's some schema's for you.
3/12/2018, 7:50:43 PM
Favs: 1
Retweets: 0
linkLast but not least, upcoming feature list with long division margins and notes from someone named Caleb. Sadly, my handwriting has not improved since those days.
3/12/2018, 7:50:44 PM
Favs: 0
Retweets: 0
link"carcass left over after kill (optional)"... nicely done young Jason.
3/12/2018, 7:50:45 PM
Favs: 2
Retweets: 0
link


About Me
Let me tell you a few things about me...
BIO
I am a third year undergraduate student at the University of Connecticut majoring in Computer Science with a minor in Data Analytics. My favorite programming language is Python. I am also a huge Boston Celtics fan.
Technical Skills
- Programming Languages: Python (Proficient), C (Proficient), Java (Familiar), HTML/CSS/JavaScript (Familiar)
- Concepts: Object Oriented Design (OOD), Algorithms, Data Structures, Software Design & Development
- Tools/Platforms: Linux (Ubuntu), Git, MS Office: Word, Excel, PowerPoint, Virtual Box, LaTeX, CAD, Adobe XD
- Language: Arabic (Bilingual)
Walgreens
Photo Specialist/Pharmacy Technician
- Produced professional photo products for customers
- Troubleshooted and repaired photo machines and online photo services
- Ordered and managed supplies for photo center
- Filled and sold prescriptions to patients
- Handled problems with prescriptions and insurance companies
ACM
Web Development Subgroup Member
- Attended workshops to help build a foundation in web development
- Created multiple mini-projects to futher reinforce web development concepts learned
- Helped new members work on individual projects to gain a greater understanding of web development


Places You've Been
Add a Place:
Location
Landmark
When did you go?
Notes
Add
Places
Location:
Landmark:
Time:
Notes:


"""Contains code that did not make it into an own module.
"""
import contextlib
with contextlib.redirect_stdout(None):
import pygame
from . import surface_composition as sc
import os
import time
from functools import lru_cache
from threading import Thread
class _PumpThread(Thread):
"""See the documentation for the interactive_mode arg from :ref:`init`"""
def run(self):
while self._run:
pygame.event.pump()
time.sleep(0.1)
def stop(self):
self._run = False
self.join()
def __init__(self):
super().__init__()
self._run = True
self.start()
[docs]def init(resolution, pygame_flags=0, display_pos=(0, 0), interactive_mode=False):
"""Creates a window of given resolution.
:param resolution: the resolution of the windows as (width, height) in
pixels
:type resolution: tuple
:param pygame_flags: modify the creation of the window.
For further information see :ref:`creating_a_window`
:type pygame_flags: int
:param display_pos: determines the position on the desktop where the
window is created. In a multi monitor system this can be used to position
the window on a different monitor. E.g. the monitor to the right of the
main-monitor would be at position (1920, 0) if the main monitor has the
width 1920.
:type display_pos: tuple
:param interactive_mode: Will install a thread, that emptys the
event-queue every 100ms. This is neccessary to be able to use the
display() function in an interactive console on windows systems.
If interactive_mode is set, init() will return a reference to the
background thread. This thread has a stop() method which can be used to
cancel it. If you use ctrl+d or exit() within ipython, while the thread
is still running, ipython will become unusable, but not close.
:type interactive_mode: bool
:return: a reference to the display screen, or a reference to the background
thread if interactive_mode was set to true. In the second scenario you
can obtain a reference to the display surface via
pygame.display.get_surface()
:rtype: pygame.Surface
"""
os.environ['SDL_VIDEO_WINDOW_POS'] = "{}, {}".format(*display_pos)
pygame.init()
pygame.font.init()
disp = pygame.display.set_mode(resolution, pygame_flags)
return _PumpThread() if interactive_mode else disp
[docs]def display(surface):
"""Displays a pygame.Surface in the window.
in pygame the window is represented through a surface, on which you can draw
as on any other pygame.Surface. A refernce to to the screen can be optained
via the :py:func:`pygame.display.get_surface` function. To display the
contents of the screen surface in the window :py:func:`pygame.display.flip`
needs to be called.
:py:func:`display` draws the surface onto the screen surface at the postion
(0, 0), and then calls :py:func:`flip`.
:param surface: the pygame.Surface to display
:type surface: pygame.Surface
"""
screen = pygame.display.get_surface()
screen.blit(surface, (0, 0))
pygame.display.flip()
[docs]def slide_show(slides, continue_handler):
"""Displays one "slide" after another.
After displaying a slide, continue_handler is called without arguments.
When continue_handler returns, the next slide is displayed.
Usage example ::
slide_show(text_screens,
partial(event_listener.wait_for_n_keypresses, pygame.K_RETURN))
(partial is imported from the functools module.)
:param slides: pygame.Surfaces to be displayed.
:type slides: iterable
:param continue_handler: function, that returns when the next slide should
be displayed.
:type continue_handler: callable with arity 0.
"""
for slide in slides:
display(slide)
continue_handler()
[docs]def empty_surface(fill_color, size=None, flags=0):
"""Returns an empty surface filled with fill_color.
:param fill_color: color to fill the surface with
:type fill_color: pygame.Color
:param size: the size of the new surface, if None its created
to be the same size as the screen
:type size: int-2-tuple
"""
if size is None:
sr = pygame.display.get_surface().get_rect()
surf = pygame.Surface((sr.w, sr.h), flags=flags)
else:
surf = pygame.Surface(size, flags=flags)
surf.fill(fill_color)
return surf
_char_mappings = {
"\r": "\n",
"\t": " "
}
[docs]def rgba(colorcode, alpha=255):
"""Returns a pygame rgba color object, with the provided
alpha value."""
return pygame.Color(colorcode * 0x100 + alpha)
[docs]def process_char(buffer: str, char: str, mappings=_char_mappings):
"""This is a convinience method for use with
EventListener.wait_for_unicode_char(). In most cases it simply appends
char to buffer. Some replacements are done because presing return will
produce '\\r' but for most cases '\\n' would be desireable.
Also backspace cant just be added to a string either, therefore, if char is
"\\u0008" the last character from buffer will be cut off. The replacement
from '\\r' to '\\n' is done using the mappings argument, the default value
for it also contains a mapping from '\t' to 4 spaces.
:param buffer: the string to be updated
:type buffer: str
:param char: the unicode character to be processed
:type char: str
:param mappings: a dict containing mappings
:type mappings: dict
:returns: a new string"""
if char in mappings:
return buffer + mappings[char]
elif char == "\u0008":
return buffer[:-1] if len(buffer) > 0 else buffer
else:
return buffer + char
[docs]def make_transparent_by_mask(surf, mask, copy=True):
"""Sets all voxels that are 1 in the mask to transparent.
if surf has no alpha channel a new image is returned, if it does have
one the behavior depends on the copy
parameter"""
if surf.get_flags() & pygame.SRCALPHA == 0:
surf = surf.convert_alpha()
elif copy:
surf = surf.copy()
pix_arr = pygame.surfarray.pixels_alpha(surf)
pix_arr[mask.astype(bool)] = 0
return surf
[docs]def make_transparent_by_colorkey(surf, colorkey, copy=True):
"""Makes image transparent, and sets all pixel of a certain color
transparent
This is useful if images should be scaled and smoothed, as this will change
the colors and make colorkeys useless, if surf has no alpha channel a new
image is returned, if it does have one the behavior depends on the copy
parameter"""
if type(colorkey) != int:
colorkey = surf.map_rgb(colorkey)
pix_arr = pygame.surfarray.array2d(surf)
mask = pix_arr == colorkey
return make_transparent_by_mask(surf, mask, copy)


If there is one tool I use the most, it has to be tmux
. I do almost everything in it.
However, as useful as it is, I feel like its not very user-friendly out-of-the-box. This post is a collection of things in my ~/.tmux.conf
that makes tmux
easier to use and to bring its more powerful capabilities within closer reach.
A better prefix
C-s
requires far less finger-flinging than the default C-b
– the keys are close enough together, and it doesn’t conflict with any key-sequence I commonly use. This is extra awesome with Capslock
mapped to Ctrl
.
Ctrl + s
is typically bound in terminals to “stop output to screen”. I can live without it, as entering “Visual Mode” in tmux
is a functional alternative.
Fix clipboard integration on macOS + vi-style bindings
Support for copying and pasting to the system clipboard doesn’t quite work on macOS. Thankfully, getting it to work takes very little effort.
First you need to install the reattach-to-user-namespace
program. You can grab it straight from Homebrew:
$ brew install reattach-to-user-namespace
Add this to ~/.tmux.conf
and you are off to the races:
# Check whether we are on macOS / OS X
if-shell 'test "$(uname)" = "Darwin"' \
'set-option -g default-command "reattach-to-user-namespace -l zsh"' ''
# vi bindings in copy-mode
setw -g mode-keys vi
# Bind `v` to enter VISUAL-like selection mode.
bind-key -t vi-copy v begin-selection
bind-key -t vi-copy y copy-pipe "reattach-to-user-namespace pbcopy"
Intuitive window splitting
# Horizontal split (left & right):
bind-key \ split-window -h -c '#{pane_current_path}'
# Verical split (top & bottom):
bind-key - split-window -v -c '#{pane_current_path}'
Compared to the default <prefix> %
and <prefix> "
, these bindings makes which way splits occur really obvious. The -c #{pane_current_path}
argument passed will start new splits in the same working directory you are on.
As of version 2.3, split-window
now understands the -f
flag, which indicates full-width or full-height splits. These are perfect when you want a “scratch” shell to appear on the bottom or to the right of everything else:
# For tmux 2.3 or newer
# Full-height horizontal split with 33% width:
bind-key | split-window -fh -c '#{pane_current_path}' -p 33
# Full-width vertical split with 33% height:
bind-key _ split-window -fv -c '#{pane_current_path}' -p 33
Tiered navigation controls
# Move between windows/tabs with `o` and `p`:
bind-key -r p next-window
bind-key -r o previous-window
# Move between splits vi-style:
bind-key -r h select-pane -L
bind-key -r j select-pane -D
bind-key -r k select-pane -U
bind-key -r l select-pane -R
Although the default <prefix> n
and <prefix> p
are easier to remember (“next” and “previous”), I find moving between windows faster with <prefix> o
and <prefix> p
as they are right next to each other. I happen to like vim-style cursor movements, so binding split navigations to <prefix> {h,j,k,l}
is just logical.
With this configuration, the navigation controls are tiered:
- Pane navigation: I can use home-row keys in vi-like bindings to move between panes in the current window.
- Window navigation: I can find
o
and p
right above the home-row keys to move between windows or “tabs” in the current session.
- Session navigation: Above
o
and p
I can use the parentheses keys to move between various sessions.
The -r
flag marks the bindings repeatable – this means they will not bring you out of prefix-mode after invocation, allowing you to repeat them or even invoke other bindings right after.
Moving panes to another window
It’s possible to move panes between different windows using join-pane
. However it is slightly cumbersome to use (you have to pass in the window’s index as the -t
argument). However using choose-window
makes it as easy as selecting a window from a list:
# Move pane to a different window. You can choose window from a list:
bind-key m choose-window -F "#{window_index}: #{window_name}" "join-pane -h -t %%"
bind-key M choose-window -F "#{window_index}: #{window_name}" "join-pane -v -t %%"
# Swap windows. Choose window to swap with from a list:
bind-key c-w choose-window -F "#{window_index}: #{window_name}" "swap-window -t %1"
You can pick a window from a list and the current pane will be sent there as a horizontal split. <prefix> M
will do the same, but will result in a vertical split.
<prefix> C-w
in will bring up a list of all windows. The current window will swap places with the one you select.
Resizing panes
# Resize panes directionally via vi-style bindings
bind-key -r C-k resize-pane -u 5
bind-key -r C-j resize-pane -d 5
bind-key -r C-h resize-pane -l 5
bind-key -r C-l resize-pane -r 5
These binds <prefix> C-{h,j,k,l}
to resize the current window by 5 columns or rows, depending on the direction. I find resizing 1 unit at a time takes a bit too long and I rarely need precise control. Resizing by 5 units is just right.
Natural numbering
Speaking of window indices, tmux
starts numbering things at 0. Zero-based index is second nature to programmers and all, but the 0
key does not appear next to 1
on any keyboard. It’s awkward for this purpose.
I think its more natural to have tmux
starting counting from 1:
# Begin numbering at 1:
set -g base-index 1
set -g pane-base-index 1
# Maintain ordinality after swapping windows; and also make sure there is no gaps after killing windows:
set -g renumber-windows on
Closing panes & windows
<prefix> x
to close the pane, <prefix> X
to close the window, and <prefix> Q
to quit the session:
bind-key x confirm-before -p "kill-pane #P? (y/n)" kill-pane
bind-key X confirm-before -p "Kill window #W? (y/n)" kill-window
bind-key Q confirm-before -p "Kill session #S? (y/n)" kill-session
A prompt will be presented to confirm the action.
Synchronize panes
Another neat trick that tmux
can do is synchronizing key-strokes across all panes in a window. I thought <prefix> &
is an apt binding to toggle the behavior:
bind-key & set-window-option synchronize-panes
For more, you can find my full tmux
configuration hosted on Github!.


{% extends "base.html" %} {% block title %}Getting started guide{% endblock %} {% block body %}
Using siena is very easy. You just create your model classes and start to use them. The only configuration is the annotation in your clases and a simple properties file. The model classes must follow some constraints:
siena.Model
. See the examples bellow for more information.all()
method like in the example. Nevertheless this is an optional step.@Table
annotation. The meaning of this annotation
will depend on the underlying siena implementation. This will be the table
name in a relational database, the entity name in the Google App Engine datastore,
the domain name in Amazon's SimpleDB,... The annotation is just named table
because is an easy to recognize nomenclature.@Column
annotations to the fields. This is very similar
to the @Table
annotation. The meaning of the annotation value
will depend on the underlying siena implementation. @Id
annotation. Some keys can be generated
automatically by the application or the database. See the example.import siena.*; import static siena.Json.*; @Table("employees") public class Employee extends Model { @Id(Generator.AUTO_INCREMENT) public Long id; @Column("first_name") @Max(200) @NotNull public String firstName; @Column("last_name") @Max(200) @NotNull public String lastName; @Column("contact_info") public Json contactInfo; @Column("boss") @Index("boss_index") public Employee boss; @Filter("boss") public Query<Employee> employees; public static Query<Employee> all() { return Model.all(Employee.class); } }
Now you just need to write a simple configuration file. In siena all the classes in the same package
are configured with the same PersistenceManager
. The configuration file must be
called siena.properties
and must be placed in the same package than the model classes.
The parameters in this configuration file depend on the siena implementation. The only shared configuration parameter is the implementation parameter. With that parameter you set what siena implementation will be used for the classes in that pacakge. Example:
implementation = siena.jdbc.JdbcPersistenceManager driver = com.mysql.jdbc.Driver url = jdbc:mysql://localhost/siena-example user = root password = 1234
The example has configured the siena-jdbc implementation. As you can see the siena-jdbc implementation requires some other configuration parameters. You can learn more about each siena implementation in the specific documentation for each implementation.
Now that your model is created and configured you can start using siena.
First of all an example:
List<Employee> employees = Employee.all() .filter("firstName", "Mark") .order("-lastName") .fetch(10);
The all()
method is a good starting point for executing queries.
That method returns a Query
object that is a representation of
a query. The Query
interface has four main methods:
filter()
, order()
, fetch()
and
get()
.
filter()
methodThis method puts restrictions to the query.
It requires two parameters: the field name (optionally
with an operator) and the restricted value. If no opeartor is specified
then "=" is assumed. You can use other operators: <, >, <= or >=. You
can call filter()
several times. The query will only return
those objects that match all restrictions. There is no way to specify
that the query will return objects that match some restrictions or others.
Comparing to SQL the filter()
method is like an AND
operator in a WHERE
clause and there is no support for
a OR
operator.
order()
methodThis is the method you will use for sorting. It requires one parameter that is the name of the field that will be used for sorting. You can concatenate a "-" before the field name for descending sort. You can call this method several times.
fetch()
methodThis method will return a list of objects that match the given
constraints sorted by the given fields. There are three versions
of this method to implement pagination. If you pass no arguments
all the objects that match the constraints will be returned.
Be careful with that because if you have several objects stored.
You can limit the maximum size of returned objects with the first
argument. And optionally you can define an offset
as second argument.
get()
methodIf you just want the first result of the query you can use
get()
. This method will return null
if there query returns no objects.
It is important to note that nothing is really queried until you call
fetch()
or get()
. The methods
all()
, filter()
and order()
just prepare the query but they don't execute it.
The Siena API is very easy. If your model classes inherith the methods
of the siena.Model
class. These methods will let
you insert, update, delete or load single objects. If you don't want
to use inheritance because you can't or you want to follow the POJO
philosophy you can use the methods of the PersistenceManager
class instead of using the methods of the siena.Model
class.
For example:
Employee e = getSomeEmployee(); // retrieve the configured PersistenceManager: PersistenceManager pm = PersistenceManagerFactory.getPersistenceManager(Employee.class); // the following two lines are equivalent: pm.update(e); // you will use it if you don't extend siena.Model e.update(); // if Employee extends siena.Model
Note: all the examples bellow use the siena.Model
methods but you will
find equivalent methods in the PersistenceManager
class.
If you have the primary keys of an object and you want to load
all its fields you just need to create an empty object,
put the primary key field values and call get()
.
Employee e = new Employee(); e.id = 123; // we know the primary keys e.get(); // this loads the object System.out.println(e.firstName);
If no object is found with those primary keys then a SienaException
will be thrown.
If you don't want to handle exceptions you can use the Query
interface.
Example:
Employee e = Employee.all().filter("id", 123).get(); System.out.println(e.firstName);
This way you will get null
instead of an exception if there is no such object.
You can even create your own static method:
public static Employee get(long id) { return Employee.all().filter("id", 123).get(); }
Inserting an object is very simple. Just load the fields with the appropiate values
and then call insert()
. If your object has some generated primary keys
you will be able to get them just after inserting the object.
Employee e = new Employee(); e.firstName = "John"; e.lastName = "Smith"; e.insert(); System.out.println(e.id); // the generated key is available
The update()
method lets you update an object in the persistence storage.
Employee e = Employee.get(123); e.firstName = "Mark"; e.update();
Finally you can delete an object using the delete()
method.
Employee e = Employee.get(123); e.delete();
The delete()
method only needs the primary keys to be loaded. So if you know
them you don't even need to execute a query to previously load the object.
In order to create a one-to-many relationship you just need to create a reference from the child class to the parent class. Example:
public class Pet extends Model { @Column("owner") public Person owner; // each pet has an owner // more fields }
It is strongly recommended to use the @Column
annotation when declaring relationships
if you are using sinea-jdbc.
To fetch all the pets of a given person you can just query filtering by that field.
Person p = somePerson(); Query<Pet> pets = Pet.all().filter("owner", p); List<Pet> somePets = pets.fetch(10);
Or you can also create an automatic-query in the Person
class.
public class Person extends Model { @Filter("owner") public Query<Pet> pets; // this is called an "automatic-query" // more fields }
Person p = somePerson(); List<Pet> somePets = p.pets.fetch(10);
As you can see the @Filter
annotation tells which field must be used to query against the
Pet
class.
In the first example at this page you can see that a Json
field has been used to store complex
data structures into one field. Well, there is another way to store complex data strctures into
one field: using embedded objects. Suppose you have a web page whose users have "profile images". Each image
has a filename, a title and a counter that counts how many times the image has been displayed.
public class User extends Model { @Embedded public List<Image> profileImages; // more fields }
You just need to put the @Embedded
annotation to the field that will store the embedded data.
This field can be an object, a java.util.List
or a java.util.Map
.
However the sotored objects must be of a class properly annotated. Let's see how:
@EmbeddedMap public class Image { public String filename; public String title; public int views; }
You have annotate your embeddec classes either with @EmbedMap
or @EmbedList
.
The embedded object will be serialized into JSON when inserted in the database. An example of
how the profileImages
field could be serialized:
[{"title": "Example 1", "views": 2, "filename": "1.jpg"}, {"title": "Example 2", "views": 20, "filename": "2.jpg"}]
When using @EmbedList
the object will be serialized into a JSON list. In this case
you must annotate the fields using @At
. This is an example:
@EmbeddedList public class Image { @At(0) public String filename; @At(1) public String title; @At(2) public int views; }
The fields must be in order as well. This is how the object would be serialized:
[["1.jpg", "Example 1", 2], ["2.jpg", "Example 2", 20]]
The JSON result is shorter but harder to understand.
The "embedded objects" feature is very powerful because you can nest embedded objects into other embedded
objects. So for example the Image
class could have other objects nested or other lists or maps
inside it. This feature also has de avantaje of knowing the structure of the data at compile time.


Map
La Liga Map
Refresh
Match day
Match detail
Home Team
Full time score
Away Team
Detail
Date
Date
Time
Time
Status
Status
Half time result
Half Time
Stadium
Stadium
Stadium Name
Location
Location
Capacity
Capacity
La Liga's Stadium
Match day


?Mmm\
EXPLORATION
OF
THE
BAHAMAS
Xi?\MLusi
NEW
YORK
BOTANICAL
GAHOgN
443248
<0>IMA6ED
PERCY
WILSON,
COLLECTOR.
MARIGUANA,
Abraham
Bay
and
Vicinity.
DEC.
6-8,
1907.
Bumelia
New
York
Botanical
Garden
Arthur
Cronquist,
1945
NEW
YORK
BOTANICAL
GARDEN
FIELD
MUSEUM
OF
NATURAL
HISTORY
01443248
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Rigid body with mass and inertia tensor and two frame connectors. All parameter vectors have to be resolved in frame_a. The inertia tensor has to be defined with respect to a coordinate system that is parallel to frame_a with the origin at the center of mass of the body. The coordinate system frame_b is always parallel to frame_a.
By default, this component is visualized by any shape that can be defined with Modelica.Mechanics.MultiBody.Visualizers.FixedShape. This shape is placed between frame_a and frame_b (default: length(shape) = Frames.length(r)). Additionally a sphere may be visualized that has its center at the center of mass. Note, that the animation may be switched off via parameter animation = false.
The following shapes can be defined via parameter shapeType, e.g., shapeType="cone":
A BodyShape component has potential states. For details of these states and of the "Advanced" menu parameters, see model MultiBody.Parts.Body.


Sign In
Sign Up
Sign In
Sign Up
Add Event
Search Events
Add Event
Search Events
Add a Center
Search Centers
Add a Center
Search Centers
SignIn/SignUp
arrow_drop_down
Events
arrow_drop_down
Centers
arrow_drop_down
Guest
event
Event Manager
menu
SignIn/SignUp
arrow_drop_down
Events
arrow_drop_down
Centers
arrow_drop_down
Guest
Modify Event ID #012346
Event Type
Wedding
Cocktail Party
Corporate Event
Engagement
Birthday Party
Other Occasion
Number of days
1
2
3
Start Date
Check Availability
Event Slots
SN
Center
Dates Available
Location
Modify Event
1
Baelor's Sept
12/17/2017
Badagry
Modify
2
Winterfell
12/18/2017
Ajegunle
Modify
3
Casterly Rock
12/19/2017
Epe
Modify
4
Dragonstone
12/20/2017
Ikorodu
Modify
Previous
Next
Your event has been modified


Lil Reese Shows Off Insane Gunshot Neck Wound: “Life’s A Gamble I Got Hella Luck”
by Biz JonesChicago rapper Lil Reese really came ‘this’ close to death. The hip-hop artist went online this week to share an up-close look at his gunshot wound to the neck.
On Sunday, Reese hit up Instagram and Twitter with updates on his well-being.
Last night, Reese broke his silence on the shooting and compared the feud to rap rivals 50 Cent and Rick Ross.
New footage surfaced online Friday of Reese appearing to drive around listening to vintage music by R&B singer Jon B.
According to reports, the attack went down Monday at a suburban intersection in Illinois.
Police said officers responded at about 2:30 p.m. to the 167th Street and Pulaski Road for reports of a shooting. Officers arrived at the scene and discovered a vehicle that had fresh blood on the driver’s seat as well as on the ground next to the driver’s side door, police said. Witnesses told police that a wounded man had been taken away by another man. (ABC 7 Chicago)


Digital Image Processing Techniques
OpenCV.js is loading...
Select Option
Convert to Gray
Resize
Original
Rotate
Thresholding
Adaptive Thresholding
LOW PASS FILTERS
Image Filtering
Image Blurring(Average)
Gaussian Blurring
Bilateral Filtering
HIGH PASS FILTERS
Sobel Filtering
Scharr Filtering
Laplacian Filtering
Canny Edge detect
Histogram equalization
Histogram Equalization
canvasOutput


Page title
We're here to help
Customer advocates
Taking transit is easy – we'll show you how! We can show members of your group how easy it is to ride buses and trains. Our customer advocates specialize in helping English language learners, youth, senior citizens and persons with disabilities or special needs. Their free presentations and onsite training can be customized to your group. Contact our customer advocates today.
We need to hear from you
Community outreach
As we continue to grow and improve our services, we want to make sure our customers and community have a voice in those decisions. Community outreach coordinators work to share information and gather feedback on upcoming transit projects, ensure prompt response to project questions and build partnerships with local organizations and groups in communities we serve.
We’ll attend your event
Planning a community or corporate event? Invite Metro Transit and we can provide how-to-ride information and updates on our latest projects, programs and initiatives. For consideration, please contact one of the Customer Advocates or Outreach Coordinators above that best bits your geographic area or project interest with the following information:
- Event name
- Date, time and location of the event
- Number of attendees
- Your contact info including phone and email
More important resources
- Riders Club
- Translated Transit Information
- For Businesses and Employers – [new “Employer Outreach” link]
- For Property Managers and New Residents
- Transit Assistance Program


| Package | Description |
|---|---|
| org.davidmoten.rx.jdbc | |
| org.davidmoten.rx.jdbc.callable.internal | |
| org.davidmoten.rx.jdbc.internal | |
| org.davidmoten.rx.jdbc.pool | |
| org.davidmoten.rx.jdbc.pool.internal | |
| org.davidmoten.rx.jdbc.tuple |
Tuples used to map ResultSet rows into strongly typed values.
|
| Class and Description |
|---|
| ConnectionProvider
Provides JDBC Connections as required.
|
| Class and Description |
|---|
| ConnectionProvider
Provides JDBC Connections as required.
|
| Class and Description |
|---|
| ConnectionProvider
Provides JDBC Connections as required.
|
| Class and Description |
|---|
| ResultSetMapper |
Copyright © 2016–2020. All rights reserved.


First Steps
Every interaction with the Challonge! API happens through the ChallongeClient
.
You have to initialize it using the api key you obtained in the previous section.
You can find it under the Challonge
namespace
using Challonge;
class Program
{
static void Main(string[] args)
{
ChallongeClient client = new ChallongeClient("YOUR API KEY HERE");
}
}
Warning
As explained previously, your api key is like your password. You shouldn't expose it like this in your code, your should rather use an external configuration file or environment variables.
The code above creates a new ChallongeClient
. By default, it is instantiated with a new
HttpClient
class, but you can
also construct it by passing your own HttpClient
.
Using the Api
The api is divided into 4 parts:
Note
The Attachments api is incomplete due to server-side issues
You can take a look at the next section to see some examples.


LibTooling
LibTooling is a library to support writing standalone tools based on Clang. This document will provide a basic walkthrough of how to write a tool using LibTooling.
For the information on how to setup Clang Tooling for LLVM see HowToSetupToolingForLLVM.html
Introduction
Tools built with LibTooling, like Clang Plugins, run
FrontendActions
over code.
In this tutorial, we'll demonstrate the different ways of running clang's
SyntaxOnlyAction
, which runs a quick syntax check, over a bunch of
code.
Parsing a code snippet in memory.
If you ever wanted to run a FrontendAction
over some sample
code, for example to unit test parts of the Clang AST,
runToolOnCode
is what you looked for. Let me give you an example:
#include "clang/Tooling/Tooling.h" TEST(runToolOnCode, CanSyntaxCheckCode) { // runToolOnCode returns whether the action was correctly run over the // given code. EXPECT_TRUE(runToolOnCode(new clang::SyntaxOnlyAction, "class X {};")); }
Writing a standalone tool.
Once you unit tested your FrontendAction
to the point where it
cannot possibly break, it's time to create a standalone tool. For a standalone
tool to run clang, it first needs to figure out what command line arguments to
use for a specified file. To that end we create a
CompilationDatabase
. There are different ways to create a
compilation database, and we need to support all of them depending on
command-line options. There's the CommonOptionsParser
class
that takes the responsibility to parse command-line parameters related to
compilation databases and inputs, so that all tools share the implementation.
Parsing common tools options.
CompilationDatabase
can be read from a build directory or the
command line. Using CommonOptionsParser
allows for explicit
specification of a compile command line, specification of build path using the
-p
command-line option, and automatic location of the compilation
database using source files paths.
#include "clang/Tooling/CommonOptionsParser.h" using namespace clang::tooling; int main(int argc, const char **argv) { // CommonOptionsParser constructor will parse arguments and create a // CompilationDatabase. In case of error it will terminate the program. CommonOptionsParser OptionsParser(argc, argv); // Use OptionsParser.GetCompilations() and OptionsParser.GetSourcePathList() // to retrieve CompilationDatabase and the list of input file paths. }
Creating and running a ClangTool.
Once we have a CompilationDatabase
, we can create a
ClangTool
and run our FrontendAction
over some code.
For example, to run the SyntaxOnlyAction
over the files "a.cc" and
"b.cc" one would write:
// A clang tool can run over a number of sources in the same process... std::vector<std::string> Sources; Sources.push_back("a.cc"); Sources.push_back("b.cc"); // We hand the CompilationDatabase we created and the sources to run over into // the tool constructor. ClangTool Tool(OptionsParser.GetCompilations(), Sources); // The ClangTool needs a new FrontendAction for each translation unit we run // on. Thus, it takes a FrontendActionFactory as parameter. To create a // FrontendActionFactory from a given FrontendAction type, we call // newFrontendActionFactory<clang::SyntaxOnlyAction>(). int result = Tool.run(newFrontendActionFactory<clang::SyntaxOnlyAction>());
Putting it together - the first tool.
Now we combine the two previous steps into our first real tool. This example tool is also checked into the clang tree at tools/clang-check/ClangCheck.cpp.
// Declares clang::SyntaxOnlyAction. #include "clang/Frontend/FrontendActions.h" #include "clang/Tooling/CommonOptionsParser.h" #include "clang/Tooling/Tooling.h" // Declares llvm::cl::extrahelp. #include "llvm/Support/CommandLine.h" using namespace clang::tooling; using namespace llvm; // CommonOptionsParser declares HelpMessage with a description of the common // command-line options related to the compilation database and input files. // It's nice to have this help message in all tools. static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage); // A help message for this specific tool can be added afterwards. static cl::extrahelp MoreHelp("\nMore help text..."); int main(int argc, const char **argv) { CommonOptionsParser OptionsParser(argc, argv); ClangTool Tool(OptionsParser.GetCompilations(), OptionsParser.GetSourcePathList()); return Tool.run(newFrontendActionFactory<clang::SyntaxOnlyAction>()); }
Running the tool on some code.
When you check out and build clang, clang-check is already built and available to you in bin/clang-check inside your build directory.
You can run clang-check on a file in the llvm repository by specifying all the needed parameters after a "--" separator:
$ cd /path/to/source/llvm $ export BD=/path/to/build/llvm $ $BD/bin/clang-check tools/clang/tools/clang-check/ClangCheck.cpp -- \ clang++ -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS \ -Itools/clang/include -I$BD/include -Iinclude -Itools/clang/lib/Headers -c
As an alternative, you can also configure cmake to output a compile command database into its build directory:
# Alternatively to calling cmake, use ccmake, toggle to advanced mode and # set the parameter CMAKE_EXPORT_COMPILE_COMMANDS from the UI. $ cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON .
This creates a file called compile_commands.json in the build directory. Now you can run clang-check over files in the project by specifying the build path as first argument and some source files as further positional arguments:
$ cd /path/to/source/llvm $ export BD=/path/to/build/llvm $ $BD/bin/clang-check -p $BD tools/clang/tools/clang-check/ClangCheck.cpp
Builtin includes.
Clang tools need their builtin headers and search for them the same way clang does. Thus, the default location to look for builtin headers is in a path $(dirname /path/to/tool)/../lib/clang/3.2/include relative to the tool binary. This works out-of-the-box for tools running from llvm's toplevel binary directory after building clang-headers, or if the tool is running from the binary directory of a clang install next to the clang binary.
Tips: if your tool fails to find stddef.h or similar headers, call the tool with -v and look at the search paths it looks through.
Linking.
Please note that this presents the linking requirements at the time of this writing. For the most up-to-date information, look at one of the tools' Makefiles (for example clang-check/Makefile).
To link a binary using the tooling infrastructure, link in the following libraries:
- Tooling
- Frontend
- Driver
- Serialization
- Parse
- Sema
- Analysis
- Edit
- AST
- Lex
- Basic


Three people shot by mistake as deer hunting begins in Michigan
by Kenneth GargerThree people, including two young children, were shot with hunting rifles during the opening weekend of deer hunting season in Michigan.
The first incident occurred on Friday when a man discharged his hunting rifle by accident inside his Crawford County home and fragments from the bullet pierced his two sons, ages 4 and 6, according to the Detroit Free Press.
The dad was attempting to place the firearm into its cover when it went off.
Fragments from the bullet went through a wall and struck the siblings inside the kitchen. They were not seriously injured, the report said.
The second shooting took place at about 5:30 p.m. Saturday when a 29-year-old man mistook his younger brother, 28, for a deer and accidentally shot him with a muzzle rifle in a Boston Township cornfield, according to the Ionia County Sheriff’s Office.
The duo got separated while searching for a deer and the older brother fired when he heard what he believed to be the animal moving around nearby.
The elder sibling called 911 once he realized he hit his brother. The victim was airlifted to a nearby hospital in serious but stable condition.
No arrests were made in either incident.


Event Location:
Microsoft Denmark
Tuborg Boulevard 12
Hellerup, , Denmark
Abstract:
In this session we will explore the Irish Economic Crisis from multiple perspectives, using Microsoft’s latest Visualisation tools including Power BI, Power Query, Power Map, Power View and SharePoint”. It starts from a very common business angle, where people need to make sense of data, fast, but don't know what questions to ask, nor how to combine available sources in a way that makes sense. This session converts the Irish Economic crisis into a story that can be explored in an interactive way, using familiar tools, in a way that people may feel should have been noticed in the run-up to the crisis. Come by to find out what led to a small country owing over 200 billion euro and if Power BI could have helped.
Speaker(s): Carmel Gunn,
Abstract:
Have you pulled a script to identify duplicates from a blog post, but couldn’t quite get it to work, because you weren’t sure what that ROW_NUMBER() function was doing. Maybe you heard talk about creating running totals without using sub-queries, but you got frustrated when the groups weren’t totaling correctly. Or maybe, you’ve never even heard of Window Functions. All are good reasons to attend this all-demo session which demystifies this versatile T-SQL tool. First, we’ll break apart the OVER clause, the key to understanding how window functions work. Then we’ll expand on each group of functions that can use the OVER clause: ranking, aggregate, and analytic functions. Finally, we’ll look at real scenarios where this tool works and talk about performance considerations. When you leave, you’ll have the fundamentals you need to fully develop your mastery of Window Functions.
Speaker(s): Christina Leo,
Abstract:
SQL Server is often I/O bound - but why? Do you feel lost when talking to your storage administrator?  This session will get you up to speed with the fundamentals of storage subsystems for SQL Server. You will learn about the different types of storage that are available, and how to decide what type of storage to use for different workload types. You will also learn useful tips and techniques for configuring your storage for the best performance and reliability. We’ll cover methods to effectively measure and monitor your storage performance so that you will have valuable information and evidence available the next time you have to discuss IO performance with your storage administrator. Come to this session to learn how to analyze I/Os as well as options to reduce the bottlenecks.
Speaker(s): Glenn Berry,
Abstract:
You have heard about Hekaton, respectively the new Acronym XTP (eXtreme Transactional Processing) and you want to know how it works under the cover? In this session we will take a closer look at the architecture, where the performance benefits come from and how it works in detail. What kind of files is SQL Server using for transactional consistency, what happens when you delete data inside the log and inside the data files. We will see the Merge-Process and the Garbage collector in action, see how memory management works for XTP enabled databases, and thereby get an in-depth understanding of how this completely new storage engine works and how to optimize for it.
Speaker(s): Andreas Wolter,
Abstract:
In this fun session, we will use Microsoft's Big Data and PowerBI tools to learn about Denmark! We will mix and mashup data from a variety of sources such as 'The Spirit Level' by Prof Richard Wilkinson, UNICEF, the World Bank and even the CIA to learn more about Denmark. BI and BA professionals need to tackle ever-increasing sources of data that are increasing in volume, velocity and variety. Let's look at fun example of global data about Denmark to look at common data storytelling by BI and BA professionals: analysing open data with varying degrees of data quality, business puzzles vs business mysteries, and deciding on which chart or graph to use when presenting data. If the 'too much data, too little information' scenario is familiar, then come to this session, which isn't just for the international visitors who come to SQLSaturday Copenhagen every year - like myself! Uncover surprising facts as we mashup, slice and dice the data, and look at Big Data and Data Visualisation
Speaker(s): Jen Stirrup,
Abstract:
In many data warehouses we model fact tables with measures based on attributes which we can count and do arithmetic upon. It is more difficult to handle fact tables with measures based on length of intervals of events happening in the source systems. So questions like "What are the typical waiting times in our order process?" are seldomly modelled in the data warehouse. Especially if the event data comes from different source systems. In this talk I will show you how Rehfeld has overcome this difficult problem using an autogenerated datawarehouse based on metadata on the objects in the EDW/DM layers. In this approach you can autogenerate the process data warehouse if only you have the timestamps present in the EDW layer and are able to correlate them. The talk will consist of slides and demos.
Speaker(s): Kennie Pontoppidan,
Abstract:
Since SQL Server 2012 a paradigm shift is occurring in how SQL Server platforms are designed and built. Come and hear why you no longer will need a SAN to create a high-available SQL Server and why I/O is no longer a problem. In this session I will go into the new storage features in Windows Server 2012 and R2 and how they relate to SQL Server 2012 and how SQL Server 2014 expands on this. Through working with the Core Windows Server team in Redmond during the development of Windows 8.1/R2 I did a lot of work with technologies which have been around for some time, but unavailable to Windows Server installations. We will talk about InfiniBand, Multi-path I/O, RDMA, RoCE, NAND Flash storage, latency and much more. Being in the Data Platforms Advisors group for the SQL Server development team in Redmond, I have worked with completely new concepts of integration between SQL Server and modern hardware, many of these surfacing in SQL Server 2014
Speaker(s): Michael Frandsen,
Abstract:
Ever tried to import a file with the Import/Export wizard?  Then you know how much work it is to specify the metadata correctly just to create a package that actually works. Wouldn't it be cool if you had a descriptive language which looks at your metadata and just created the packages for you? This is what BIML is all about. In this session I explain what BIML is, how it works and I'll show you how you can generate your packages and quickly respond to changes. You can expect a demo rich session with lots of notes from the field and practical examples. This is not just for BI developers, DBA's or SQL dev's who need to import or export data occasionally will learn some quick and easy tricks as well.
Speaker(s): André Kamman,
Abstract:
We have all been in situations where writing a GROUP BY query just didn’t do the job, or aggregation over groups required more work than could be fit into one single SQL statement. For that purpose Window functions have been around since SQL Server 2005. But it is first with SQL Server 2012 that the power of using these functions have been truly released. With the introduction of new functions and optimized performance it is now possible to implement solutions which leverage the strength in the language structure without losing performance in the result. In this demonstration packed session I will introduce the concept of Window Functions, show samples of usages and dive into the workings of the optimizer.
Speaker(s): Steen Dybboe,
Abstract:
This session will give you an idea for some alternative uses of Master Data Management. And how Easy it is to instantiate MDS from SSIS with T-SQL and stored procedures. Also a short walk through of the tools in MDS from sql server 2012
Speaker(s): Kenneth Nielsen,
Abstract:
SQL Server 2012 brings a wide range of changes from its previous versions - one key change is the way SQL Server memory is managed. With releases prior to SQL Server 2012, there were 2 memory managers, these have been merged into 1 with the latest version, and that’s just the start of the changes for SQL Server memory. This session will dive into questions related to memory primarily for SQL Server 2012.
Speaker(s): Neil Hambly,
Abstract:
Have you ever wanted to replay your application workload be that because you upgraded to a new hardware, added new indexes or something else? Now there's a feature for that! It's called Distributed Replay and in this session you will learn how this new feature in SQL Server 2012 can help you resolve that problem!
Speaker(s): Boris Hristov,
Abstract:
You’ve heard it said, “If you have to do it twice, automate it.” Cut the learning curve and get a real handle on this powerful automation tool. This session walks you through a dozen scripts to simplify and easily automate time-consuming and tedious elements of your day to day job. This isn’t stuff you’ll use SOMEDAY, these are scripts you can use when you get home tonight. Harness the power of Power Shell to easily find Servers short on space. Script out tables and constraints across all of your databases at once. Backup databases and restore them to a different environment. These tricks and many others will allow PowerShell to simplify your job like no other tool.
Speaker(s): Aaron Nelson,
Abstract:
Knowledge about use cases and workload is important input to your data modelling. Different kinds of compression can be relevant depending on your usage scenario. Storing data economically also means that data should be easy to use. Comparison of different compression methods (non lossy, lossy, downsampling for visual presentation).
Speaker(s): Bjorn D. Jensen,
Abstract:
In this session, you will be introduced to the secret sauce of the PDW - MPP and column-store. You will also learn about some of the differences between a PDW and SQL Server, and be taken through the life-cycle of a PDW project, based on the V1 and V2 projects Mark has worked on
Speaker(s): Mark Stacey,
Abstract:
Attend this session to get an overview of two different approaches to automate your testing of Analysis Services cube. The first approach captures snapshot of the cube metadata/structure and a representative sample of values from all measures. With a set of reports it is possible to compare the snapshot and find the differences - ie before and after deployment. The second approach uses the test framework nBI to test result sets, performance, syntax, structure and dimension members.
Speaker(s): Just Blindbaek,
Abstract:
Being able to accomodate the most demanding requirements on security is more important now than ever. This session will take you through a variety of approaches on how to implement basic to complex security on dimensions in SSAS. A quick intro through the GUI will bring us to XMLA and AMO as the weapon of choice. Different concepts on hierarchy security models will also be demonstrated.
Speaker(s): Jens Vestergaard,
Abstract:
In every project on Business Intelligence there comes a time when the code needs to be deplyed to the production environment. No more development, no more manual work. But what about the partitions on the cube? Do we really need to tell and learn the DBA how to handle that on a periodic plan? The answer is simple: No!
Speaker(s): Brian Boenk,
Abstract:
DML is used in most cases without thinking about the multiple operations for the db engine. This session will give a deep dive into the internal storage engine down to record level. After finishing the theory (and inside the theory) the differen DML commands and their tremendous operational tasks for the db engine will be investigated. SEE, what a workload will be caused by a "forwarded record". What tremendous workload will occur in a page split. What happens if an existing record will be updated in fixed length attributes
Speaker(s): Uwe Ricken,
Abstract:
What has the biggest impact on SQL Server overall performance? Hardware, SQL Server configuration or maybe query tuning? No, none of those frequently discussed options. They are important, but the single, most important factor is the database design. A third normal form is great, but sometime a database really should be denormalized to gain a performance boost. This is where indices shine. During this session you will see: how important a proper table design can be, when to use indices on computed columns and why they are way better than triggers, how to create useful indexed views and how to asses their costs and benefits.
Speaker(s): Marcin Szeliga,
Abstract:
In SQL Server 2014 query processing has been improved. What we can expect from new cardinality estimator? Does it really estimate better? Will our execution plans be better after migration to 2014? All of them? Is the key ascending column statistics problem solved in new version? Do we finally can have more than 200 steps in the statistics histogram per table? What about column correlation and cardinality estimates - are the predicates still completely independent? This session will answers all these questions and will demonstrate new query processing capabilities and compare them with those from SQL Server2012.
Speaker(s): Miloš Radivojević,
Abstract:
The new QA function in Power BI will make it possible to ask questions to your Excel Power Pivot models and get a visualization back. In order to give the best experience for the users of your model you need to prepare it for questions. In this session I will go through how to do this - and will also introduce the natural language syntax and thereby give you an idea of how you can help the user to get the right answer to their questions and the correct visualization as the first answer. QA will really enable you to rock the way that users interact with data.
Speaker(s): Erik Svensen,
Abstract:
In this session we will go through the topics of performance, scalability and availbility - the 3 core topics that every DBA needs to know. Performance is at the core and required for every database application (small or mission-critical). In this talk we will go through the concepts, tools and procedures that will help you in monitoring and start fine-tuning the performance or find the root-cause on your data platform. The subject covered here is excerpted from my book "Microsoft SQL Server 2008 R2 Administration cookbook". This will also be an ideal beginning for any IT person who is willing step-into DBA world.
Speaker(s): Satya Jayanty,
Abstract:
Learn how to optimize DAX measures and queries in this very technical and deep-dive session. Starting from simple performance issues, you will see how to read and understand the query plan of a DAX query. With this information, you will be able to locate bottlenecks in calculation and improve performance by changing DAX expressions, moving the workload from the formula engine to the storage engine and get a complete understanding of the internals of the DAX query engine. A previous knowledge of the xVelocity In-Memory engine and some basics of the DAX Query Engine are suggested in order to follow this session in a more productive way.
Speaker(s): Marco Russo,
Abstract:
So your CTO wants you to migrate your mission critical database application to the cloud. What's involved and what are the pitfalls? In one hour we will take a sample ecommerce application and database, show tools available for both schema and data migration and then demo performance and scalability impacts.
Speaker(s): Bob Duffy,
Abstract:
This session will demonstrate some of the functionality of the scripting components in Integration Services based on practical use-cases and real world applications. You'll see how to parse stange fileformats, how to create your own Data-Driven subscription of Reporting Services among other things.
Speaker(s): Mikael Wedham,
Abstract:
With an alarming number of high-profile data breaches in the last 12 months, perhaps SQL Server encryption should be a topic to revisit in your data protection strategy. After a brief overview of column-level encryption and TDE, we discuss SQL Server encryption with regard to performance, application-tier and operations.
 Lots of checksum errors logged. DBCC CheckDB won't even run on the database. And worst of all - you have no backups! Now what do you do with this 20GB binary blob of an MDF file? In this demo-rich session I will briefly introduce the internals of MDF files while primarly concentrating on how to manually extract data from corrupt databases. I will be using the OrcaMDF RawDatabase framework to do most of the parsing, which will also be explained during the session.
Speaker(s): Mark S. Rasmussen,
Abstract:
So you know all about heaps, clustered indexes, and nonclustered indexes, but are still not satisfied? Then this is just the session for you! Hugo will explore advanced features such as included columns, indexed views, and filtered indexes. You will find out how they are stored on disk, and how SQL Server uses them to satisfy queries. Then, you will see the tools SQL Server itself hands you to help identify just the right subset of indexes. And finally, you will get an stunning demonstration of just how bad you can hurt performance by following all those recommendations and creating too many indexes.
Speaker(s): Hugo Kornelis,
Abstract:
Well - they named it SQL2014 In-Memory OLTP tables - BUT that does not mean we can't optimize our BI solutions with this new feature. This demo intensiv session is build around a number of hypothesis that are testet and show what we can - and cannot optimize with In-Memeory tables covering both the ETL and (R)OLAP angels of the BI process.
Speaker(s): Rasmus Reinholdt,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: http://dk.linkedin.com/in/kennethmnielsen/
Contact: http://funkylab.com
Kenneth M. Nielsen currently work at Microsoft as Data Platform Solution Architect, focusing on data services on Azure. Previously worked as managing consultant and teamlead for the company Rehfeld Partners in Denmark. He has worked at various consulting firms and worked on many small/large/very large bi installations in Denmark over the last 12 years. He really likes to advice the customers to take the right decisions, but also maintains a high technical knowledge, so he can act at both architect and developer.
LinkedIn: http://www.linkedin.com/in/sqlbi
Contact: https://www.sqlbi.com/blog/marco
Marco is a Business Intelligence consultant and mentor. He wrote several books about Power BI, Analysis Service, and Power Pivot. He also regularly writes articles and white papers that are available on sqlbi.com. Marco is a Microsoft MVP and an SSAS Maestro, the highest level of certification on Microsoft Analysis Services. Today, Marco focuses his time with SQLBI customers, traveling extensively to train and consult on DAX and data modeling for Power BI and Analysis Services. Marco also teaches public classes worldwide. Marco is a regular speaker at international conferences like Microsoft Ignite, PASS Summit, and SQLBits. He also enjoys delivering evening sessions at local user groups during his trips.
LinkedIn: http://www.linkedin.com/in/markrasmussen
Contact: http://improve.dk
Mark S. Rasmussen, a SQL Server MVP, has worked extensively with SQL Server, primarily focused on performance optimization and internals. Besides SQL Server, he is also proficient in the Microsoft .NET development stack, with a decade of experience. Fueled by his interest in the nitty-gritty details, Mark started the OrcaMDF open-source project, which aims to provide a completely standalone parser for SQL Server MDF files. He actively blogs at http://improve.dk and tweets at @improvedk.
LinkedIn: http://www.linkedin.com/in/kennie
Contact: http://www.pontop.dk/
Kennie Nybo Pontoppidan is a senior program manager in Microsoft working in the Dynamics NAV server backend team. He has worked in the dangerous field between developers, dbas, customers and project managers for many years and done his part of mistakes as a developer before that in his 15+ years in the it industry. He enjoys working with databases and really, really enjoys his daily dose of sql. Kennie has no humor.
Contact: http://sqlblog.com/blogs/hugo_kornelis/default.aspx
Hugo is co-founder and RD lead of perFact BV, a Dutch company that improves analysis methods and develops computer-aided tools to generate completely functional applications from the analysis deliverable. The platform for this development is SQL Server. In his spare time, Hugo likes to share and enhance his knowledge of SQL Server by frequenting newsgroups and forums, reading and writing books and blogs, and attending and speaking at conferences. Hugo is also a SQL Server MVP since 2006.
LinkedIn: http://www.linkedin.com/profile/view?id=270775013amp;trk=tab_pro
Contact: http://www.sqlmaster.de
Uwe Ricken is working with IT systems since the 90’s. The primary passion for developments with Microsoft SQL Server expanded in 2007 with his engagement as a DBA for Deutsche Bank AG in Frankfurt am Main. After 6 years of operational experiences as a DBA and over 14 years as a developer of complex database models he achieved the “Microsoft Certified Master – SQL Server 2008” certification which “was” the highest technical certification. In the same year he earned his first award as a Data Platform MVP for his support to the Microsoft SQL Server community in Germany and Europe. Uwe Ricken is a speaker on many international conferences and events and preferred topics are “Database Internals”, “Indexing” and “Development”.
Contact: http://sqlserverdba.dk/
Hans Hansen is a freelance database consultant based in Copenhagen, Denmark and has been working with SQL Server since version 6.5. While his SQL Server focus is on OLTP, core DBA tasks, security and performance tuning his current interests centers around Azure, ‘Internet-of Things’ and complex event processing. Hans offers freelance services at SQLServerDBA.dk and is also a partner at Trustmint.
Contact: http://christinaleo.net
Christina Leo is a Cloud Solution Architect at Microsoft specialising in the Data and AI Platform. Prior to joining Microsoft in 2016, she worked as an independent consultant focusing on T-SQL and BI development, as well as database performance tuning in the finance and investment banking sector. When she isn't sharing her 18 years of technical experience with the data community, you can find her racing around the Solent on a 40' sailboat or often in the Thames on a little Laser.
Contact: http://www.jenstirrup.com
Jen is a database strategist, small business owner, SQLFamily and community advocate, public speaker and blogger. Jen was elected Director-At-Large (elect) for the Professional Association of SQL Server, responsible for the EMEA regions plus the Virtual Chapter portfolio. Jen is passionate about all things data and business intelligence, helping leaders derive value from their Microsoft SQL Server, SharePoint and Office365 investments.
Contact: http://www.wedham.com
Mikael Wedham is the first SQL Server MCM in Sweden and the only one who also is a Microsoft Certified Trainer. He has been paid to do things in SQL Server since 1993. His long experience makes him an appreciated speaker at events and conferences all over Europe. To be prepared for deep dives, he is also certified as an Open Water Scuba Instructor.
Contact: http://blogs.prodata.ie/author/bob.aspx
Bob Duffy is a SQL Server MVP from Dublin, Ireland who is MCA, MCM. and Analysis Services Maestro certified. Bob works as a Database Architect at the Prodata SQL Centre of Excellence where he specializes in business intelligence and performance tuning.
Steen Dybboe works as a senior BI consultant at Netcompany A/S with focus on designing and implementing Data Warehouses. In the Microsoft Business Intelligence sphere he has a particular interest in designing and developing database solutions and has been working with SQL Server since version 6.5, both as certified developer and instructor. Beside database technology Steen has a wide experience on various programming platforms
LinkedIn: http://dk.linkedin.com/in/jvestergaard
Contact: http://www.t-sql.dk
Jens performs the traditional BI disciplines from imports in Integration Services through data consolidation in Analysis Services, to report in Power BI or Reporting Services. Jens has worked with The Stack since SQL 2000 and has a core competence in Integration Services and Analysis Services. Along with the certified skills in Microsoft SQL Server, Jens has also worked with Microsoft .Net platform for more than 15 years and currently manages a BI Platform in Azure for the CatMan Solution application(s).
LinkedIn: http://www.linkedin.com/in/andreaswolter
Contact: http://www.andreas-wolter.com/blog/
Andreas Wolter is a Program Manager for SQL Server- and Azure Security at Microsoft. In this role he is working on Security features of SQL Server, Azure SQL Database and Managed Instance. He is currently focusing on “Separation of Duties”-concepts and RBAC-Integration. He has 18 years of experience with SQL Server before joining Microsoft and is the founder of Sarpedon Quality Lab, the Germany-based company specialized on SQL Server HA, Performance and Security. He is Microsoft Certified Master (MCM) for SQL Server and Microsoft Certified Solutions Master for the Data Platform (MCSM) and was recognized as MVP for multiple years in row.
LinkedIn: https://www.linkedin.com/in/brianbonk
Contact: http://www.bonk.dk
Brian is a BI consultant born in 1979, certified MCSE: BI and MCSE: Data Platform from Denmark with around 10 years experience of BI. His knowledge is broad around the whole spectrum of a BI project. Brians main interest is SSIS and cubes. The few spare hours besides work is being used on a spiritual approach to life and the familiy.
Contact: http://andrekamman.com
André is a freelance SQL Server specialist. In previous roles he’s done a lot of DBA work on 100’s of servers where he discovered his love for Powershell and automating processes in general. Today the better part of his day he’s building and tuning ETL processes. André is a SQL Server MPV, Dutch PASS Chapter Leader and organiser of SQL Rally Amsterdam and SQLSaturday Holland
LinkedIn: https://www.linkedin.com/in/sqlvariant
Contact: http://sqlvariant.com/
Aaron Nelson is an author, public speaker, blogger, and leader in the community. He has over 15 years of experience in architecture, Business Intelligence, development, and performance tuning of SQL Server. Aaron has received many certifications and is a six time winner of the Microsoft MVP Award. Aaron leads the PowerShell Virtual Group of PASS (SQLPS.io), is a board member of PowerShell.org, and is a volunteer at his PASS Local Group, AtlantaMDF.
LinkedIn: http://dk.linkedin.com/eriksvensen
Contact: http://eriksvensen.wordpress.com
Microsoft MVP - Dataplatform Leader of Denmark - Power BI Usergroup Passionate about Power *, Excel , Analysis Services, Reporting Services. CTO @CatManSolution - delivering a BI as service solution for suppliers to FMCG Retailers based on the Microsoft BI Stack
LinkedIn: http://dk.linkedin.com/in/bdjensen/
Bjørn Dörr Jensen, Decision Intelligence Specialist, who is developing a system that turns raw sensor data into recommended actions to improve turbine availability and decreasing cost of energy. Working for Vestas Wind Systems A/S with Microsoft SQL Server 2016. Worked as a (PL/)SQL Developer from 2000 - 2006 at TDC, Stibo and IBM. Broad experience with structured query languages. Microsoft Certified Solutions Expert (Data Management and Analytics). M. Sc. in Physics and a Six Sigma Green Belt certification.
LinkedIn: http://dk.linkedin.com/in/michaelfrandsendk/
Michael Frandsen is an Microsoft MVP on Cloud amp; Datacenter and the lead consultant on areas of technical consulting, performance optimization and migration/consolidation projects, with special focus on storage, scalability and virtualization. He started with Windows NT 3.1 and SQL Server 4.21a and has been involved in Tech betas and TAP customers ever since. He has also contributed to best-practices at Microsoft and HP, through working with Microsoft product groups and SQLCAT in Redmond and HP Ramp;D in Palo Alto and Houston
LinkedIn: https://pl.linkedin.com/in/marcinszeliga
Data Philosopher. Since 2006 invariably awarded Microsoft Most Valuable Professional title in the Data Platform category. A speaker at numerous conferences across Europe, as well as at user groups meetings. The author of many books and articles devoted to Microsoft Data Platform. An independent consultant, database-centric application practitioner and architect totally focused on SQL Server and Azure. Huge fan of Data Science and Machine Learning.
LinkedIn: http://uk.linkedin.com/in/neilhambly
Contact: http://dataidol.com/NeilHambly
Neil Hambly is a SQL Server consultant, founder and consultant at Datamovements, a Gold Microsoft Data Analytics Consulting company. Neil has 20+ years in a variety of SQL Server roles and is an MCT. He is a regular presenter (200+ events) at user groups, and PASS events, including PASS Summit and SQLSaturday, and many UK events (SQLBits, SQLRelay). Neil is the leader of PASS London (UK), a Professional Development VC, a Melissa Data MVP, and a SQL Cruise Technical Lead, who loves Guinness, whisky, and dancing.
LinkedIn: http://ie.linkedin.com/in/carmelgunn/
Contact: http://blogs.prodata.ie
Carmel is the Managing Director of the Prodata SQL Centre of Excellence in Dublin, Ireland, where she is a data management specialist, working in the areas of analytics and visualisations. As a committee member for the SQL Server Ireland User Group, she has played an active roll in bringing 2 SQLSaturdays to Dublin, and is heavily involved in the SQL community.
LinkedIn: https://www.linkedin.com/profile/public-profile-settings?trk=prof-edit-edit-public_profile
Contact: https://glennsqlperformance.com/
Glenn works as a Principal Consultant for Dr. DMV, LLC in Elizabeth, CO. He was a Data Platform MVP from 2007-2017, and he has a whole collection of Microsoft certifications, including MCITP, MCDBA, MCSE, MCSD, MCAD, and MCTS, which proves that he likes to take tests. His expertise includes DMVs, high availability, hardware selection, performance tuning, and Azure SQL Database. He is also an Adjunct Faculty member at University College - University of Denver, where has been teaching since 2000. He has completed the Master Teacher Program at Denver University - University College. He is heavily involved in the SQL Server community, and is a frequent speaker at user groups, SQLSaturdays, and the PASS Community Summit.
LinkedIn: http://dk.linkedin.com/in/rasmusreinholdt/
Contact: http://rasmusreinholdt.wordpress.com
Rasmus is the Data Warehouse architect at UNOPS, the implementation arm of the UN, based in Copenhagen, Denmark. He has worked with Microsoft BI since 2005 both as a developer and architect, building large solutions on every release from sql2005 and onwards. Rasmus is certified is MSCE SQLServer (Data platform amp; BI), a long time speaker at various SQLSaturdays, PASS SQLRally Nordic and SQLBits. He also co-organizes SQLSaturday Copenhagen and blogs at http://rasmusreinholdt.wordpress.com.
LinkedIn: http://at.linkedin.com/pub/milos-radivojevic/1b/7bb/290/de
Contact: https://milossql.wordpress.com/
Miloš Radivojević is a database consultant located in Vienna, Austria. He is Data Platform MVP and specializes in SQL Server for application developers and performance and query tuning. Currently, he works as a principal database consultant in bwin GVC (the largest regulated online gaming company in the world). He is co-founder of the SQL Pass Austria and speaks regularly at local and international database conferences. He is also co-author of the books SQL Server 2016 Developer's Guide, SQL Server 2017 Developer's Guide and Mastering SQL Server 2017.
Contact: http://MarkGStacey.net
Mark Stacey founded the Aphelion Software Group, and works tirelessly to cross the business/technical boundaries in Business Intelligence, working in both SharePoint and SQL. He has published two books on BI - Sharepoint 2010 BI and Visual Intelligence and frequently speaks at both SQLSaturday and SharePoint Saturday events. Mark is one of the few Microsoft PDW trainers, and has trained in Africa, India and Europe on the PDW, as well as all over the world on other technologies
LinkedIn: https://uk.linkedin.com/sqlmaster
Contact: http://www.sqlserver-qa.net
My experience surrounded with high focus on the data platform with a track record of defining strategy, designing and delivering digital transformation migrations with major enhancements to current working methods. Worked in a capacity of Head of Data Engineering, Enterprise Data Architect and Solutions Key career accomplishment recognition as an industry expert technical excellence from the Microsoft as Data Platform Most Valuable Professional (MVP) recognition since the year 2006 (13 years as MVP and counting), which recognizes exceptional technical community leaders worldwide who actively deliver, present share their extraordinary contributions, high quality, and real-world expertise. Twitter pod (http://twitter.com/sqlmast
LinkedIn: http://www.linkedin.com/profile/view?id=5113407
Contact: http://blog.justb.dk
Independent BI consultant with extensive experience in all phases of BI development on Microsoft SQL Server, Azure and Power BI. Founder and coordinator of Microsoft Business Intelligence Professionals Denmark (MsBIP.dk) and Power BI UG Denmark (PowerBI.dk). Is a Microsoft Certified Trainer at Orange Man.
LinkedIn: http://bg.linkedin.com/in/borishristov
Contact: http://borishristov.com/blog/
Boris is a SQL Server Consultant, but also an Author for Pluralsight and a SQL Server MVP. He is frequently speaking at conferences all accross Europe and is heavily involved in training students and organizations in what he calls quot;The Art of SQL Serverquot;. Boris is frequently blogging and is the host of SQLHangouts.
The following is a list of sponsors that helped fund the event.


Welcome to our beautiful page. Our salmon cookies are light, delightful, and fishy.
We are dedicated to serve you delicious salmon cookies! From our family to yours.
We beautifully hand craft our Cookies to perfection!
We offer a different variety of sugar salmon cookies using our customized cookie cutters to your liking!
Checkout our T-Shirt merchandise. Order Now!!


I am often waiting to line to get lunch, deciding what I can afford to get and realizing I have no idea. I check my bank account and go through a hundred calculations in my head about when I am getting paid, what bills are coming out when, and whether or not 7 dollars is more important to me right now than that burrito.
This is really the question we are trying to answer when we budget: How much can I spend? To answer the question of how much I can spend on lunch, most budgeting solutions want to know our bank information, our transaction history, and how much we have spent on lunch in the past six months. What if there was a way to keep our information as private as we want and require minimal effort to maintain.
Our solution is to zero in on answering the question, “How much can I spend?” and ignore all the others. By lowering the importance of understanding past spending habits we can tell you how much you can spend now without collecting personal information and requiring as little information from you as possible.
An MVP would include:
For anyone looking for a budgeting solution there are more options than you can possibly research. Of course, too many options can create a lot of pressure to find the “right” solution, and after picking a solution that seems right the pressure to budget “correctly” can cause a lot of stress. Many people are comfortable with the budgeting solutions they have found and stay on top of their budgets monthly. Others, however, over commit to a budgeting process, get overwhelmed and abandon their budget entirely. For those people, a simpler budgeting solution that fits their needs and personality is hard to find on the market.
We have conducted limited user research and have determined that there are as many budgeting approaches as there are people interested in budgeting. Budgeters vary widely in:
For our purposes we focus on two criteria to differentiate budgeters and their preferred budgeting method:
Existing budgeting software generally falls along this range with products like Mint.com on the side of minimal effort to maintain but the maximum amount of information given to the software provider, and the home Excel spreadsheet solution on the side of maximum effort to maintain but minimal privacy lost.
We have positioned our product to require minimum invasion of privacy while maintaining a very low level of effort to maintain. We do this by boiling budgeting down to its most essential elements centered on what we believe is the only question a budgeter really needs answered:
How much can I spend right now?
We then add as much flexibility as possible and strive to create an easy to use platform with a forgiving and stress free set of calculations in the background.
Our app will require some effort to set up; we will ask users to input all of their known expenses and income in a calendar format.
Jake had an email account that was hacked which lead to items bought with his information on Amazon. Jake works hard for his money and wants to have fun. He doesn’t want to worry about third parties having access to his information
Jen has started and abandoned more budgets than she can count. She tried Mint and realized she just didn’t care about how much she spent on groceries. All Jen really wants to know is how much she can spend this month without running out of money next month. Jen’s paychecks come every two weeks while all of her other expenses are monthly. More than once she has overdrafted because she thought she had plenty of money until all her bills were due at once.
The back-end was built in Ruby on Rails utilizing Devise for security and a TDD methodology for the more complex algorithms using RSpec. The front-end was built utilizing both ruby gems and Vue.js. A video of the MVP is found below.
Before launching live the front end was moved to a separate application and redesigned and recoded using React and React Router.
We will take a lean ux approach by launching our app as quickly as possible and get feedback live. Before launching live will will take opportunities we find to get as much design feedback as possible.
In future iterations of this product we plan to address the following:


A set of 40 industrial machines one could use to build a small civilisation. The tools are modular and they describe it as a “life sized lego set”. They’ve spent two years building eight prototypes including a brick maker that can spit out 5000 bricks in a day.
This is extremely cool. Via Kottke.


|
VItA
1.1
Virtual Iterative Angiogenesis library
|
#include <PartiallyVascularizedDomain.h>
Public Member Functions | |
| PartiallyVascularizedDomain (string filenameHull, vector< string > filenameVascularRegions, vector< string > filenameNonVascularRegions, GeneratorData *instanceData) | |
| PartiallyVascularizedDomain (string filenameHull, vector< string > filenameVascularRegions, vector< string > filenameNonVascularRegions, int nDraw, GeneratorData *instanceData) | |
| PartiallyVascularizedDomain (string filenameHull, vector< string > filenameVascularRegions, vector< string > filenameNonVascularRegions, int nDraw, int seed, GeneratorData *instanceData) | |
| int | isSegmentInside (point xs, point xf) |
| double | getCharacteristicLength () |
| double | getDLim (long long int nVessels, double factor) |
| double * | getLocalNeighborhood (point p, long long int nVessels) |
| double | getSize () |
| virtual point | getRandomPoint () |
| vtkSmartPointer< vtkOBBTree > & | getLocator () |
| int | getDraw () |
| deque< point > & | getRandomInnerPoints () |
| vtkSmartPointer< vtkPolyData > & | getVtkGeometry () |
| Public Member Functions inherited from AbstractDomain | |
| AbstractDomain (GeneratorData *instanceData) | |
| AbstractDomain (GeneratorData *instanceData, vector< int > growingStages) | |
| virtual | ~AbstractDomain () |
| virtual int | isValidElement (AbstractVascularElement *element) |
| virtual double | getMinBifurcationAngle () |
| virtual void | setMinBifurcationAngle (double minAngle) |
| long long int | getPointCounter () const |
| bool | isIsConvexDomain () const |
| void | setIsConvexDomain (bool isConvexDomain) |
| GeneratorData * | getInstanceData () |
| void | setInstanceData (GeneratorData *instanceData) |
| const vector< int > & | getGrowingStages () const |
| void | setGrowingStages (const vector< int > &growingStages) |
| bool | isIsBifPlaneContrained () const |
| void | setIsBifPlaneContrained (bool isBifPlaneContrained) |
| double | getMinPlaneAngle () |
| void | setMinPlaneAngle (double minPlaneAngle) |
| Public Member Functions inherited from IDomainObservable | |
| IDomainObservable () | |
| void | registerObserver (IDomainObserver *observer) |
| void | notifyObservers () |
Protected Member Functions | |
| void | generateRandomPoints () |
| void | removeRandomOuterPoints () |
Protected Attributes | |
| deque< point > | randomInnerPoints |
| Protected Attributes inherited from AbstractDomain | |
| vector< int > | growingStages |
| GeneratorData * | instanceData |
| long long int | pointCounter |
| bool | isConvexDomain |
| double | volume |
| double | minAngle |
| bool | isBifPlaneContrained |
| double | minPlaneAngle |
Private Attributes | |
| vtkSmartPointer< vtkPolyData > | vtkTransportRegion |
| vector< vtkSmartPointer< vtkPolyData > > | vtkVascularizedRegions |
| vector< vtkSmartPointer< vtkPolyData > > | vtkHollowRegions |
| vtkSmartPointer< vtkOBBTree > | locator |
| vector< vtkSmartPointer< vtkOBBTree > > | hollowLocators |
| double | characteristicLength |
| int | nDraw |
| int | seed = -1 |
| mt19937 | generator |
This domain features three different type of volumes: (i) transport volume; (ii) vascularized volumes; (iii) non-vascularized volumes. A transport volume allows that existent vessels within it, create terminals to vascularized volumes. Thus, its space may prone anastomose from existent arteries to vascularized regions, but no terminals can be created in it. A vascularized volume allowed the anastomose in its existent vessels and the creation of terminals within it. Lastly, non-vascularized volumes do not allowed vessels to enter exit nor generate terminals. It is mandatory that vascularized regions be within the transport volume.
| PartiallyVascularizedDomain::PartiallyVascularizedDomain | ( | string | filenameHull, |
| vector< string > | filenameVascularRegions, | ||
| vector< string > | filenameNonVascularRegions, | ||
| GeneratorData * | instanceData | ||
| ) |
Constructs a domain shaped by filenameHull
(transport domain) with vascularized and non-vascularized regions contained in filenameVascularRegions
and filenameNonVascularRegions
respectively.
| filenameHull | Domain description. |
| filenameVascularRegions | Vascularized regions descriptions. |
| filenameNonVascularRegions | Non-vascularized regions descriptions. |
| PartiallyVascularizedDomain::PartiallyVascularizedDomain | ( | string | filenameHull, |
| vector< string > | filenameVascularRegions, | ||
| vector< string > | filenameNonVascularRegions, | ||
| int | nDraw, | ||
| GeneratorData * | instanceData | ||
| ) |
Constructs a domain shaped by filenameHull
(transport domain) with vascularized and non-vascularized regions contained in filenameVascularRegions
and filenameNonVascularRegions
respectively. Also, itgenerates batches of nDraw
random points each time that the domain is with no more points.
| filenameHull | Domain description. |
| filenameVascularRegions | Vascularized regions descriptions. |
| filenameNonVascularRegions | Non-vascularized regions descriptions. |
| nDraw | Random points generated at each batch. |
| PartiallyVascularizedDomain::PartiallyVascularizedDomain | ( | string | filenameHull, |
| vector< string > | filenameVascularRegions, | ||
| vector< string > | filenameNonVascularRegions, | ||
| int | nDraw, | ||
| int | seed, | ||
| GeneratorData * | instanceData | ||
| ) |
Constructs a domain shaped by filenameHull
(transport domain) with vascularized and non-vascularized regions contained in filenameVascularRegions
and filenameNonVascularRegions
respectively. Also, itgenerates batches of nDraw
random points each time that the domain is with no more points.
| filenameHull | Domain description. |
| filenameVascularRegions | Vascularized regions descriptions. |
| filenameNonVascularRegions | Non-vascularized regions descriptions. |
| nDraw | Random points generated at each batch. |
| seed | Seed for random points generation. |
|
virtual |
Estimates a characteristic length for the current domain. This length is useful to estimate the perfusion volume of the domain.
Implements AbstractDomain.
|
virtual |
Minimum distance between a new vessel terminal and the tree based on the current terminal perfusion. This is lower bound criteria for the vessel length and also aids toward a spatially homogeneous terminal distribution.
| nVessels | Quantity of terminals in the current tree. |
| factor | Factor used to scale a perfusion measure in order to estimate the DLim value. |
Implements AbstractDomain.
| int PartiallyVascularizedDomain::getDraw | ( | ) |
Returns the number of random points created in each batch of random generations.
|
virtual |
Returns the local neighbors to the p
point locus. The amount of neighbors is estimated based on the current terminal perfusion.
| p | Central point of the neighborhood. |
| nVessels | Amount of terminals in the tree. |
Implements AbstractDomain.
| vtkSmartPointer< vtkOBBTree > & PartiallyVascularizedDomain::getLocator | ( | ) |
Returns the locator used to test inside segments.
|
virtual |
|
virtual |
|
virtual |
|
virtual |
Returns the vtkPolydata with the domain representation.
Implements AbstractDomain.
Returns if the segment defined by the vertexes xs
and xf
is inside the current transport domain without intersecting non-vascularized regions.
| xs | Start point of the segment. |
| xf | End point of the segment. |
xs
and xf
is inside the current domain otherwise 0. Implements AbstractDomain.
|
private |
Characteristic length for the domain.
|
private |
Random generator.
|
private |
Cell locator responsible to determine if a segment is inside a non-vascularized region.
|
private |
Cell locator responsible to determine if a segment is inside the domain.
|
private |
Amount of points randomly generated when no more points are available.
|
private |
Random instance seed.
|
private |
Non-vascularized subdomains represented by vtkPolydata.
|
private |
vtkPolydata description of the transport domain.
|
private |
Vascularized subdomains represented by vtkPolydata.


Everywhere you go, you see people you know or that you don't, and hear people talk that you either know or don't. I myself doing drugs for years since early childhood hads a rude awakening 2 years ago in the summer.
I was so happy that I had one year left of high school and I was 'done'. My friend since childhood 'Faith', had just moved into an apartment around the corner from me with her older cousin and her child. One night I went over to play cards and mybe smoke some pot and there were two guys there. They were not Faith's friend but her cousin's. They offered me lines and of course being broke I said yes. It was free....at least I thought. When that ran out her cousin suggested all of us go up to one of the guy's house. We agreed and I went hom to get a bathing suit ( there was a jacuzzi). I only was in it for a short time when were got there and got changed because I felt uncomfortable. We did more and more and more coke and thee was still a ton left. I had only done coke 3 times prior to this and before it wasn't even more than 3 lines.
When we left to go home, one of the kids rode with us and said he was going home too. Instead he walked me home. I felt wierd but you know how it is on coke you don't want to be mean to anyone. He kept giving me more and more and when I was on the computer checking something he pushed me over onto the couch and started to have sex with me. I kept saying no no no no but he wouldn't listen and there was nothing that I could do to stop him. He was way bigger than me and I was far too messed up. He did it to me more than once that night/ early morning. He even did it with a cucumber that he took from my fridge. When he was going to leave his friend was to pick him up and his friend raped me too. I never thought it was going to end and it finally did.
I never told my parents or the police because of being such a troubled teenager and all the things I did to my mother I couldn't help but save her from this type of pain. She would leave me home every weekend so she could go to camp and this is what her baby did. Got high and raped. So everytime I hear people talking about drugs I tell them not to do them and I silently remember what happened to me....I never graduated either. If I don't know who they are I shake my head and wish to God I never did them in the first pleace because it would of never happened to me
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.