IUPUI Institute for Integrative AI, "Collaborative Research Grant," PI,
$17,000, 2021 - 2022
Indiana Department of Education, "Indiana Governors Emergency Education Relief Grant," PI,
$1,179,000, 2020 - 2022
IUPUI School of Education, "Block Grant for Doctoral Student Graduate Assistantship Funding," PI,
$30,000, 2020 - 2021
IUPUI Office of the Vice Chancellor for Research, "Developing Community Types Based on School-Centered Antisemitic Incidents," PI,
$35,000, 2019 - 2020
IU Consortium for the Study of Religion, Ethics, and Society, "Effects and Echoes: The Impacts of White Nationalism on Religious Communities," PI,
$6,000, 2019 - 2020
IUPUI Office of International Affairs, "A Comparative Analysis between the US and Hungary (Understanding the Indiana Community)," PI,
$2,000, 2019
IUPUI Program Review and Assessment Committee, "Evaluating the Cross-Curricular Integration of Technology in IUPUI's Urban-Focused Teacher Education Program," PI,
$5,000, 2018 - 2019
IUPUI Office of the Vice Chancellor for Research, "Facing Ourselves, Facing Our Students: Contemplative Pedagogies and Approaches for Exploring the Thorny Issues of Race and Religion with Teachers in Predominantly White Christian Suburban Schools," PI,
$35,000, 2018 - 2019
IUPUI 50th Anniversary Fund, "Reclaiming the New Colossus: From the MS Saint Louis to Contemporary Times," PI,
$2,500, 2018 - 2019
IUPUI Office of International Affairs, "Partnership Building with Western Galilee College and Northern Israel," PI,
$2,300, 2018
IUPUI School of Education, "Block Grant for Doctoral Student Graduate Assistantship Funding," PI,
$30,000, 2017 - 2018
IU School of Education, "Building Peace and Justice through Critical Inquiries of Place with Technology," PI,
$18,000, 2017 - 2018
Leonard and Marion Freeman Charitable Fund, "Strengthening IUPUI's Jewish Community Through New Traditions," PI,
$800, 2017 - 2018
IUPUI Curriculum Enhancement Grant, "Upgrading the Online and Hybrid Learning to Teach with Technology Course to Support Justice-, Equity- and Inclusion-Oriented Teacher Preparation," PI,
$5,000, 2017 - 2018
Claude Worthington Benedum Foundation, "Fostering a Network of Science Inquiry-Focused Schools with the EnergyMakers Curriculum," PI,
$107,000, 2015 - 2016
Fairmont State University Foundation, "Foundation Grant," PI,
$2,500, 2013 - 2014
Lynch School of Education at Boston College, "Summer Dissertation Grant," PI,
$1,500, 2011


Putting it together¶
In the past four days we have been introduced to a number of topics related to geodynamic modelling:
- Physical processes
- Solving equations
- Programming concepts in Python/NumPy
- Numerical methods
- Benchmarking numerical solutions
Now we turn to how these different topics are related to one another in our design of a 2D thermomechanical numerical geodynamic model. As we will see, there are a number of different factors we must consider in the model design, and the order in which we perform various actions is important.
Processes to consider¶
First off, what kinds of processes do we need to consider in our 2D geodynamic numerical modelling code?
- Heat transfer in 2D
Conduction
Production
Advection
- Material thermal properties
- Thermal conductivity
- Concentration of heat-producing elements
- Heat capacity
- Stokes flow
Momentum and continuity equations
- Material mechanical properties
- Viscosity
Material advection (related to of Stokes flow)
Interactions between processes/materials¶
How might various processes we consider above interact with one another? This is an important consideration because we need to know in which order we should handle the different processes. In the Earth, materials move and transfer heat simultaneously, but in our model we will solve the Stokes flow and heat transfer equations separately.
- Stokes flow solution will affect advection in heat transfer code
- Temperature will affect viscosity of model materials
- Velocities from Stokes flow will influence size of time step for material advection
Structure of a 2D thermomechanical code¶
With the list of processes and their interactions given above, how should we design our numerical modelling code? In what order should we do the different steps?
Figure 1. An example of a flow chart for the steps needed to simulate geodynamic processes in 2D.
Above we see an example of the order in which various processes and numerical procedures should be executed. Notably, we calculate the velocities for Stokes flow first, temperature after that (using the Stokes flow velocities), and move the markers after the new temperature values have been interpolated onto them. Note that in our code we will not perform step 4 above.
Limitations¶
Given the various physical processes we have discussed earlier in the course, and the model design described above, what are the potential limitations of our 2D model?
- 2D, so no three-dimensional deformation
- No plasticity, no elasticity


Class: Aws::Lightsail::Types::CacheSettings
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb |
Overview
Describes the cache settings of an Amazon Lightsail content delivery network (CDN) distribution.
These settings apply only to your distribution's cacheBehaviors
(including the defaultCacheBehavior
) that have a behavior
of
cache
.
Constant Summary
Instance Attribute Summary
-
#allowed_http_methods ⇒ String
rw
The HTTP methods that are processed and forwarded to the distribution's origin.
-
#cached_http_methods ⇒ String
rw
The HTTP method responses that are cached by your distribution.
-
#default_ttl ⇒ Integer
rw
The default amount of time that objects stay in the distribution's cache before the distribution forwards another request to the origin to determine whether the content has been updated.
-
#forwarded_cookies ⇒ Types::CookieObject
rw
An object that describes the cookies that are forwarded to the origin.
-
#forwarded_headers ⇒ Types::HeaderObject
rw
An object that describes the headers that are forwarded to the origin.
-
#forwarded_query_strings ⇒ Types::QueryStringObject
rw
An object that describes the query strings that are forwarded to the origin.
-
#maximum_ttl ⇒ Integer
rw
The maximum amount of time that objects stay in the distribution's cache before the distribution forwards another request to the origin to determine whether the object has been updated.
-
#minimum_ttl ⇒ Integer
rw
The minimum amount of time that objects stay in the distribution's cache before the distribution forwards another request to the origin to determine whether the object has been updated.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#allowed_http_methods ⇒ String
(rw)
The HTTP methods that are processed and forwarded to the distribution's origin.
You can specify the following options:
GET,HEAD
- The distribution forwards theGET
andHEAD
methods.GET,HEAD,OPTIONS
- The distribution forwards theGET
,HEAD
, andOPTIONS
methods.GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE
- The distribution forwards theGET
,HEAD
,OPTIONS
,PUT
,PATCH
,POST
, andDELETE
methods.
If you specify the third option, you might need to restrict access to your distribution's origin so users can't perform operations that you don't want them to. For example, you might not want users to have permission to delete objects from your origin.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end
#cached_http_methods ⇒ String
(rw)
The HTTP method responses that are cached by your distribution.
You can specify the following options:
GET,HEAD
- The distribution caches responses to theGET
andHEAD
methods.GET,HEAD,OPTIONS
- The distribution caches responses to theGET
,HEAD
, andOPTIONS
methods.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end
#default_ttl ⇒ Integer
(rw)
The default amount of time that objects stay in the distribution's cache before the distribution forwards another request to the origin to determine whether the content has been updated.
Cache-Control max-age
, Cache-Control s-maxage
,
and Expires
to objects.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end
#forwarded_cookies ⇒ Types::CookieObject (rw)
An object that describes the cookies that are forwarded to the origin. Your content is cached based on the cookies that are forwarded.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end
#forwarded_headers ⇒ Types::HeaderObject (rw)
An object that describes the headers that are forwarded to the origin. Your content is cached based on the headers that are forwarded.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end
#forwarded_query_strings ⇒ Types::QueryStringObject (rw)
An object that describes the query strings that are forwarded to the origin. Your content is cached based on the query strings that are forwarded.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end
#maximum_ttl ⇒ Integer
(rw)
The maximum amount of time that objects stay in the distribution's cache before the distribution forwards another request to the origin to determine whether the object has been updated.
The value specified applies only when the origin adds HTTP headers
such as Cache-Control max-age
, Cache-Control s-maxage
, and
Expires
to objects.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end
#minimum_ttl ⇒ Integer
(rw)
The minimum amount of time that objects stay in the distribution's cache before the distribution forwards another request to the origin to determine whether the object has been updated.
A value of 0
must be specified for minimumTTL
if the
distribution is configured to forward all headers to the origin.
# File 'gems/aws-sdk-lightsail/lib/aws-sdk-lightsail/types.rb', line 1586
class CacheSettings < Struct.new( :default_ttl, :minimum_ttl, :maximum_ttl, :allowed_http_methods, :cached_http_methods, :, :forwarded_headers, :forwarded_query_strings) SENSITIVE = [] include Aws::Structure end


Welcome to your AWS serverless Express application. This example application has several resources configured for you to explore. State is stored in memory in a given container, and thus ephemeral - see Understanding Container Reuse in AWS Lambda for more information.
Returns a list of all users.
curl users
Creates a new user.
curl users -X POST -d '{"name":"Jake"}' --header 'content-type: application/json'
Returns a single user.
curl users/1
Updates an existing user.
curl users/1 -X PUT -d '{"name":"Jane"}' --header 'content-type: application/json'
Deletes an existing user.
curl users/1 -X DELETE


Ficus Bonsai
system controls
LIGHT
WATER
AUTO
RESERVOIR
84.5%
humidity
25.7°F
temperature
Day Light
light exposure
97
moisture
Container for Chart 1
Container for Chart 2
Container for Chart 3
Container for Chart 2


Hi
I am trying to backup my data from the Pi server to my Windows network. I have set up Samba on the Pi and have managed to set up a share so that /var/lib is visible to the windows network. I have no trouble copying the timestore folder to a backup Windows directory and have got a scheduled backup running.
However Mysql is a different matter and I guess it is to due to security restrictions. When I try to copy the folder I get "You require permission from the computers administrator to make changes to this folder"
If I try to open the folder I get a similar message.
I have made an attempt to set up Trystan's backup scripts and have set up Wampserver and emoncms on a Windows PC on the network but again I could not get past the stage requiring the Pi mysql files to be copied to the Windows mysql folder.
Any help with this appreciated.
TIA
Ian
Re: Help appreciated on how to copy Mysql file to Windows network
To backup mysql, I have been successfully using automysqlbackup. Take a look here: http://sourceforge.net/projects/automysqlbackup/ and here: http://www.linux.com/learn/tutorials/659107-how-to-do-painless-mysql-ser...
I am also backing up from my Pi to a shared folder on my Windows PC.
Fyi - I started by creating a tar of the timestore files, but on one occasion it failed, saying that the contents had changed during the operation. To get round this, I now stop the service, do the backup (which is really quick) and then start the service.
Nick
Re: Help appreciated on how to copy Mysql file to Windows network
Many thanks Nick,
Just working through set up now.
Regards
Ian


--- layout: post title: "Garlic and Onions" date: 2020-06-15 15:15:00 +0000 tags: onions, grief image: imagecredits: ---
I'd have him chop the onions and garlic for me. He was so much more fastidious than me. I don't mind if they're all different sizes. I try to accomplish the prep work for meal quickly. He would spend so long, making sure everything was diced, not chopped, and uniformly so.
I will think of him every day, and I will have real reasons now to cry quietly as I chop the onions.


VISION
Our vision is to have a corruption free environment in our country among all institurions
where every individual would think atleast twice
before doing a wrong act.
MISSION
Our mission is to provide a platform for people to report the issues that they have and we contact them and get an
insight into the misdoing that they have observed. We then visit the place and observe the actions of the person who
is committing a crime. We try to provide the information to NGO's and other interested parties.


Cluster Tuning Guide
Overview
This document aims to provide a sensible workflow for understanding and tuning available parameters in Kubernetes. This guide is for application owners and cluster managers. It is intended to help illustrate and inform configuration decisions. Whereas the Kubernetes documentation provides in-depth information on individual parameters, this guide highlights the relationships between them and implications of each one on the rest of the cluster. By the end of this document, you will have a clearer understanding of how your responsibilities impact the stability, utilization, and performance of your overall Kubernetes environment.
The content of this guide was presented at the 2019 KubeCon in San Diego. This presentation may be viewed here.
Motivations
IT organizations deploy applications to cloud environments, public or private, with one primary goal: keep applications online to maximize the value add for their business and keep costs to a minimum. More specifically, they want to optimize stability and utilization of their environment while meeting the availability and performance requirements of their applications. Kubernetes enables them to achieve these goals by providing a framework to run distributed systems resiliently. Kubernetes offers various features and options to help mitigate disruption to application workloads. Application owners and cluster managers are encouraged to work together to mitigate the risks posed by these disruptions to maximize the value of Kubernetes for their organizations.
Involuntary Disruptions
Disruptions are classified into two categories: involuntary and voluntary. Involuntary disruptions are any case of an unavoidable hardware or software failure. Examples of this include:
- physical hardware failure
- cloud provider or hypervisor failure
- kernel panic
- network partition
- pod eviction caused by resource contention
Among these examples, pod eviction is the only one unique to Kubernetes, and it is discussed in-depth throughout this guide. The other types of involuntary disruptions are common across all cloud environments, whether a container orchestrator such as Kubernetes is used or not.
Voluntary Disruptions
Voluntary disruptions are those caused by an application owner or cluster manager. Unlike involuntary disruptions, voluntary disruptions are actions performed to Kubernetes. Examples of disruptions caused by an application owner include:
- deleting the controller responsible for managing a pod
- updating a deployment’s pod template
- directly deleting a pod
Examples of disruptions caused by a cluster manager include:
- draining a node for a repair or upgrade
- scaling the cluster up or down (can also be caused by an autoscaler)
- removal of a pod to permit another one to schedule on a node
A cluster manager, application owner, automation, or an underlying hosting provider can all cause the above listed voluntary disruptions. Fortunately, Kubernetes provides several constructs to application owners and cluster managers to mitigate the risks presented by each of these disruptions.
Topics
It is helpful to categorize tunable parameters by the persona that may be responsible for them: application owner or cluster manager. For each parameter, you will learn the risks posed by the default Kubernetes configuration, the benefit of tuning this parameter, and the implications of your tuning decisions on the rest of your cluster.
Managed by application owners:
- Disruption-Tolerant Applications
- Limits
- Requests
- Pod Disruption Budgets
- Affinity & Anti-Affinity
- Pod Priority & Preemption
Managed by cluster operators:
- Live Restore
- PodsPerCore
- LimitRanges
- Resource Quotas
- Soft Eviction
- Hard Eviction
- Kube Reserved
- System Reserved
- Housekeeping Interval
For both audiences, topics are listed top-to-bottom by their relative impact-to-risk. The top-most items will have the greatest impact on your environment while introducing minimal risk. As you approach the bottom of the list, parameters have less of an impact (relative to the others) and/or introduce risk if implemented incorrectly. Examples of misconfigured parameters:
- for Application Owners, misconfigured or “abuse” of pod priority can negatively impact scheduling of other teams' workloads
- for Cluster Operators, misconfigured Kubernetes & System reserved flags can cause significant instability in the cluster.
Application Owner
The parameters discussed in this section are of primary concern to application owners, although understanding them will help anyone who works with Kubernetes.
Disruption Tolerant Applications
This guide assumes that the applications you are deploying are prepared to take advantage of Kubernetes. This includes Kubernetes-specific configuration such as liveness probes, readiness probes, logging to stdout etc. This guide also assumes your application can tolerate temporary disruptions.
Resource Limits
Resource limits provide a way to limit pod resource consumption and contribute to the overall stability of the cluster. By default, pods do not have resource limits and their consumption of resources is unbounded. This is problematic because a pod is free to consume all available resources on a node.
Figure 1: BestEffort pod (no limits or requests)
Quality-of-Service
(QoS) is a classification assigned to each pod by Kubernetes for the purposes of scheduling and pod eviction. A BestEffort pod is one with no resource limits or requests (requests are discussed in the next section), and is the lowest QoS assigned by Kubernetes. Figure 1 shows a pod with a QoS of BestEffort. The green bar represents utilization and the dotted line indicates it is a variable quantity. In this case, utilization is unbounded and free to consume all available CPU and memory.
Figure 2: Two replicas of a BestEffort pod
Compressible vs. Incompressible Resources
Figure 2 shows a node with two replicas of Pod A. Notice the CPU is fully utilized and each replica is using 50% of the available capacity, yet the single replica in Figure 1 is using over 50% of the available CPU capacity. The CPU consumption of each replica in Figure 2 has been throttled down to 50%. This is because CPU is a compressible resource.
When a compressible resource (such as CPU) is fully utilized, its consumers will be throttled.
Figure 2 also shows the memory consumption of both pods, however memory is an example of an incompressible resource. The red bar in Figure 2 indicates memory that the second replica of Pod A attempted to consume, but the node did not have available. At this point, the node must reclaim resources to ensure stable operation. Although there are ways for a node to protect itself when this occurs, it does introduce uncertainty and put the stability of the node at risk.
Risk of Unbounded Resource Consumption
When memory approaches full utilization, a node’s kubelet invokes pod eviction to reclaim resources and ensure the node remains stable. If pods consume all available memory before the kubelet begins the eviction process, then Kubernetes workloads will be competing with system daemons for memory and it is up to the node’s oom_killer to respond. Once this occurs, the best case scenario is for the pod to be killed by the oom_killer. Unlike pod eviction, a pod killed by the oom_killer may be restarted on the same node by the kubelet based on its restart policy. This means a pod may enter a cycle of consuming too much memory, being killed by the oom_killer and restarted by the kubelet. This cycle may continue without the pod being rescheduled because it is never successfully evicted. This is problematic because it raises the possibility of system daemons, such as Docker, crashing and causing the entire node to become unstable.
Risk of Docker Termination
If you use Docker for your container runtime, under its default configuration, it will terminate all pods under its supervision when it terminates. This means that resource contention between pods and node daemons could potentially crash Docker and all other containers on the node. This setting is configurable and discussed later in the Live Restore section.
Figure 3: Pod with limit
Resource Limits
Figure 3 shows a pod with a limit, indicating the point at which compressible resources (CPU) are throttled and incompressible resources (memory) are limited. If the pod consumes more memory than its memory limit specifies, it will be killed by the kubelet to prevent overconsumption of resources, mitigate the noisy neighbor problem and ensure node stability.
While resource limits do help mitigate overconsumption of resources, they do not help the scheduling process within Kubernetes. In other words, resource limits help optimize stability, but do not have a big impact on utilization. For example, resource limits would not prevent the situation described in Figure 2 from occurring. The Kubernetes scheduler may still attempt to schedule a pod on a node without sufficient resources, resulting in the pod being evicted and rescheduled on another node. Scheduling may be influenced by resource requests, which will be discussed in the next section.
Setting Appropriate Resource Limits
A resource limit set too low may result in a pod being throttled or evicted. However, a resource limit set too high may result in underutilization of node resources. Slack is the difference between a pod’s resource limit and its actual utilization. The optimal resource limit for a pod depends on application performance characteristics and requirements, and may be determined manually by observing the workload with monitoring tools. Vertical Pod Autoscaler
is an upstream effort aimed at automating the process of optimizing pod slack to achieve high utilization and effective scheduling.
Effect of CPU Limits on Latency-Sensitive Workloads
The diagrams in this document use memory as an example of an overcommitted resource to trigger pod eviction. Memory is a good example because memory overcommit poses the greatest risk to node stability. Although CPU overcommit isn’t a risk to node stability, it does have significant performance implications. If your workloads are latency-sensitive, we recommend viewing a Zalando presentation that goes into depth on this topic. We also recommend reviewing the Kubernetes documentation on CPU Management Policies and Topology Manager.
Resource Requests
Resource requests allow you to specify a minimum amount of a resource required for a pod to function and allow the scheduler to optimize utilization.
Burstable Pods
Figure 4: Burstable pod (request < limit)
A pod with a QoS of burstable has at least a resource request assigned to it. If a limit is assigned, the request must be less than the limit for the pod to be classified by Kubernetes as burstable (Kubernetes will not allow pods with requests configured to be higher than limits). Figure 4 shows a burstable pod, indicated by having requests and limits specified and the request lower than the limit. The darker shade of green indicates the amount of resource that is indicated by the request.
Figure 5: Node from scheduler’s point-of-view
The Kubernetes scheduler considers resource requests when evaluating whether a node has sufficient capacity for a pod to be scheduled. Figure 5 is an illustration of a node from the scheduler’s point of view. For the pod illustrated in Figure 4, the Kubernetes scheduler evaluated the node by considering whether the specified request would have fit on the node. Figure 5 illustrates this by showing how many resource requests would have fit on the node. Although an implementation of resource requests does affect scheduling, it will not always prevent the problem illustrated in Figure 2. This is not always a problem however, as the difference between a pod’s limit and request is what allows for the node to be overcommitted.
Resource Overcommit
Overcommit allows a node’s aggregate resource limits to be greater than the available capacity for a given resource, which optimizes cluster utilization at the expense of stability. This is acceptable when the workloads do not always consume resources up to their limit, but instead infrequently burst up to that limit. This does introduce risk, as it allows multiple workloads to burst at the same time and force pod eviction or node instability to occur. An appropriate amount of overcommit depends on your application requirements.
Guaranteed Pods
A QoS of guaranteed is assigned to pods where the request is equal to the limit.
Figure 6: Two replicas of Pod A scheduled across two nodes
Figure 6 shows two replicas of Pod A across two nodes, each pod with a QoS of guaranteed. The entirety of the available utilization is indicated by dark green. Figure 6 is an example of how the scheduler may avoid the problem illustrated in Figure 2. Because the request is equal to the limit, the scheduler sees that Node 1 cannot provide sufficient resources for a second replica of Pod A. The scheduler concludes Node 2 is sufficient because Pod A’s resource request is less than Node 2’s available capacity.
Pod Priority and Preemption
Pod priority indicates a pod’s importance relative to other pods. It is also used to prioritize which pods will be evicted when a node is out of resources or when a higher-priority workload is being scheduled (also known as preemption). Pod priority ensures stability of high-priority workloads when nodes are highly-utilized.
Pod Eviction Order
Figure 7: Node under memory pressure
Figure 7 shows a node with multiple pods (all of varying QoS classifications) scheduled to it. The node is also under memory pressure, which means it will begin the eviction process.
| Eviction Order | QoS | Priority | Utilization | Usage / Request | Pod Label |
|---|---|---|---|---|---|
| 1 | BestEffort | 1 | 2% | N/A | D |
| 2 | BestEffort | 2 | 5% | N/A | C |
| 3 | BestEffort | 3 | 20% | N/A | A |
| 4 | BestEffort | 3 | 10% | N/A | B |
| 5 | Burstable | 3 | N/A | 2 | F |
| 6 | Burstable | 2 | N/A | 0.5 | E |
| 7 | Guaranteed | 1 | N/A | 1 | G |
Table 3 outlines the details of each pod illustrated in Figure 7, and the order in which the pod would be evicted. Note that the kubelet only evicts pods until the node is no longer under pressure, this table is just an example of how pods are prioritized.
The prioritization of pods during the eviction process first considers a pod’s QoS class. BestEffort and Burstable pods are considered first. Then, pods are ranked by priority and usage above request. BestEffort pods do not have a request, so this value is considered to be zero during the eviction process. After this, Guaranteed pods and Burstable pods whose usage is below their request are considered.
Node Out-of-Memory Behavior
If a node’s resources are consumed faster than the eviction process can reclaim resources, the node must rely on the oom_killer to ensure node stability. This document will not go into detail on this process, as the process is not configurable and our goal is to avoid this situation as it puts node stability at risk. Refer to the Kubernetes documentation for details on this process.
Pod Disruption Budgets
A Kubernetes cluster will experience various disruptions throughout its lifecycle. Some are involuntary such as a VM failing or a network partition, and others are voluntary such as cluster scaling or node draining. To optimize stability, you should strive to mitigate risk across all lifecycle events. Pod Disruption Budgets (PDBs) allow an application owner to optimize application stability and availability by indicating how many concurrent voluntary disruptions their application can tolerate. This information is used by Kubernetes to block voluntary disruptions if the PDB requirement would be violated by performing the voluntary disruption.
By default, Kubernetes is unaware of the availability requirements of the applications that are deployed to it. As a result, PDBs are a crucial interface between application owners and cluster managers because they enable a way for Kubernetes to track an application’s availability requirements. PDBs are especially important for stateful applications with data sharded across replicas, or high priority deployments where application-level availability is of concern.
PDB Example
The following example is an illustration of the example given in the Kubernetes documentation.
Figure 8: Cluster prior to node draining
Figure 8 shows a 3-node cluster with its respective Deployment and PDB objects. There is also an unrelated pod, Pod X, deployed to node 1.
Figure 9: Cluster during node draining with pods rescheduled
When a voluntary disruption occurs, such as a cluster manager draining a node in preparation for a node upgrade, Kubernetes will consult each deployment’s respective PDB and block the operation if the PDB would be violated by the operation. Figure 9 shows the state of a cluster during a node draining operation that was allowed by Kubernetes because the deployment’s PDB would not have been violated.
Figure 10: Cluster with node cordoned and rescheduled pods running
Once a node is drained, its state is considered to be “cordoned”. Figure 10 shows the Kubernetes cluster after a node is successfully cordoned and its pods have been rescheduled.
Figure 11: Cluster with node cordoned and rescheduled pods running
As mentioned earlier, if a voluntary disruption is attempted on a cluster that would result in a PDB being violated, the action will be blocked by Kubernetes. Figure 11 shows the Kubernetes cluster after a cluster manager attempts to perform a drain operation on Node 2. Pod E, a part of the deployment, is stuck in “Pending” state because there are not enough resources remaining to schedule it. Furthermore, Kubernetes will refuse to drain Pod D from the node because that would violate the PDB. This operation would block, and Figure 11 represents the state the cluster would be in at this point.
Affinity & Anti-Affinity
It is a common requirement for highly-available applications to be dispersed across physical hardware, or for an application to require hardware that is specific to a node in the cluster. By default, Kubernetes is unaware of these topology requirements. Affinity & anti-affinity allow an application owner to express these requirements to optimize application availability during voluntary disruptions.
In the previous example, if the cluster had a fourth node then anti-affinity could have been used to influence the scheduler to reschedule Pod D to it. This would have prevented two pods from the deployment to land on the same node.
Hard Requirement vs. Soft Preference
A hard requirement is one that would prevent a pod from being scheduled if it is not met. A soft preference would not prevent a pod from being scheduled if it is not met. For example, the nodeSelector field should be implemented to express a hard requirement for a pod that requires a specific hostPath volume to be present. An example of a soft preference is an application with high-availability requirements that needs to spread across physical machines and can be expressed by affinity & anti-affinity or taints & tolerations.
This requirement may be preferred, but not required during voluntary disruptions for example.
Cluster Operator
The parameters discussed in this section are of primary concern to cluster managers, although understanding them will help anyone who works with Kubernetes. The diagrams in this section build off of those found in the previous Application Owners section.
Live Restore
Live restore is a feature of Docker that allows containers to continue running when the Docker daemon is unavailable. By default, this feature is disabled when installing Docker. Docker configuration is also out of scope for kubeadm, resulting in cluster managers often overlooking this setting. If using Docker for your container runtime, we recommend enabling this feature to prevent containers from being shutdown if the Docker daemon is terminated to optimize node stability.
Pods Per Node
Kubernetes is configured with a default limit of 110 pods per node. VMware recommends Cluster Managers remain aware of this default and adjust it as necessary according to workload requirements to optimize utilization. This value is configurable as a kubelet flag and may be set when installing Kubernetes with kubeadm.
LimitRanges and Resource Quotas
As mentioned earlier, containers are configured to run with unbounded resources by default._ LimitRanges_ allow cluster managers to set a default resource request and limit requirements for all pods in a namespace. If a pod is created without this requirement being met, it will automatically be added by the LimitRanger admission controller.
Resource quotas allow cluster managers to limit aggregate resource consumption on a per-namespace basis. These are easy ways to bound resource consumption across all pods and namespaces to optimize stability and utilization (as detailed in Resource Limits and Resource Requests).
Eviction Thresholds
As mentioned earlier, kubelet evicts pods on a node when it is under pressure for a resource to ensure node stability. Eviction thresholds define the threshold at which the eviction process begins on a node. A hard eviction threshold is one in which pods are immediately evicted after being crossed. A soft eviction threshold is one in which a grace period must pass before kubelet begins to evict pods.
Visualizing Eviction Thresholds
Figure 12: Unbounded utilization of workloads and daemons
A node’s resources are consumed by Kubernetes workloads or by system daemons. Figure 12 illustrates this concept by showing workload and daemon utilization increasing from left-to-right. A fully utilized resource would be indicated by these two bars filling the rectangle.
Figure 13: Node with eviction thresholds shown
Figure 13 shows a node’s memory resources with default eviction threshold. Note that eviction thresholds are bounded by a solid line. Furthermore, eviction thresholds are only affected by workload utilization surpassing them and not by daemon utilization. By default, the resource consumption of system daemons on a cluster is unbounded. Bearing this in mind, Figure 13 is also representative of a Kubernetes cluster configured by kubeadm in its default configuration. (unbounded workload utilization, unbounded daemon utilization and a hard eviction threshold for memory).
Configuring Eviction Thresholds
By default, kubelet is configured with only a hard eviction threshold with these parameters as ofv1.16.2:
evictionHard:
imagefs.available: 15%
memory.available: 100Mi
nodefs.available: 10%
evictionPressureTransitionPeriod: 5m0s
These values represent the defaults configured for kubelet regardless of the resources available on a particular node. To override these parameters, override them when installing your cluster with kubeadm. VMware recommends cluster managers remain aware of this default and configure their cluster with the node resources and application requirements in mind.
Kube & System Reserved
Kubernetes also provides a means for cluster managers to limit resource consumption of daemons to optimize utilization. Kube reserved reserves compute resources for Kubernetes-related daemons and system reserved reserves compute resources for other daemons.
Figure 15: Node with eviction threshold, kube, and system reserved
Node Allocatable Constraints
Figure 16a: Node CPU with Node Allocatable and Node Allocatable Constraints highlighted
Figure 16b: Node Memory & Ephemeral Storage with Node Allocatable and Node Allocatable Constraints highlighted
Node allocatable constraints are what eviction thresholds, kube reserved and system reserved are collectively referred to as. This name is derived from the fact that they are what determines node allocatable, which is how much of a resource is available for consumption by pods. In other words, a node’s allocatable capacity is equal to its capacity minus node allocatable constraints. Figures 16a and 16b illustrate the relation between these values for CPU, memory and ephemeral-storage. Note that Figure 16a does not contain an eviction threshold. This is because eviction thresholds only apply to non-compressible resources such as memory and ephemeral storage.
Note that the addition of kube and/or system reserved will introduce a second eviction threshold for non-compressible resources (for example, memory and ephemeral-storage). In Figure 16b, eviction is triggered either when pod utilization exceeds allocatable, or when the total utilization (pods and daemons) exceeds the eviction threshold. For compressible resources (CPU), the addition of kube and/or system reserved will move the threshold at which that resource is compressed because it affects the size of allocatable.
Tuning Node Allocatable Constraints
When configuring eviction thresholds, keep in mind that kube reserved and system reserved flags have a direct effect on the allocatable capacity of each node.
As a cluster manager, your primary means of tuning stability vs. utilization of your cluster is by adjusting node allocatable constraints. Always have eviction policies configured and tuned appropriately relative to node size and workload resource consumption. Only after adequate monitoring is in place, consider enforcing kube reserved to bound resource consumption of Kubernetes-related daemons. Finally, only enforce system reserved if absolutely necessary and after exhaustive profiling of daemon resource consumption via monitoring tools.
Housekeeping Interval
Kubernetes does not maintain a real-time understanding of resource consumption on its nodes. Instead, kubelet periodically evaluates the eviction thresholds on each node at a preconfigured housekeeping interval. Because of this, it is possible for a rapid increase in memory consumption to cause instability on a node. Kubernetes’ default housekeeping interval is 10 seconds, but VMware recommends cluster managers adjust this parameter if they know their workloads can rapidly increase in memory consumption.
Figure 17: Linear increase in memory consumption with default housekeeping interval (10 seconds)
The risk posed by the default housekeeping interval is illustrated in Figure 17. Notice that the utilization captured by the kubelet is only updated every 10 seconds even though the memory is increasing linearly with time. In this example, eviction thresholds would not be triggered until the moment utilization hit 100%, which may be too late to mitigate the risk posed by out-of-memory handling.
Figure 18: Spike in memory consumption with default housekeeping interval (10 seconds)
The worst-case scenario is for memory to become fully utilized for some amount of time before the utilization captured by the kubelet is updated to reflect this. Figure 18 shows this scenario with the actual utilization at 100% for 5 seconds before the kubelet notices.
Figure 19: Spike in memory consumption with default housekeeping interval of 10 seconds
For deployments that consume memory rapidly and are at risk of the situation described in Figure 18, consider reducing the housekeeping interval. Figure 19 shows how changing the housekeeping interval to 5 seconds (from the default of 10 seconds) can mitigate this problem.
Fault Tolerance
One of the greatest benefits of tuning the parameters discussed in this guide is that failover scenarios become much more predictable. A node failure in a Kubernetes cluster with default configuration will have an unpredictable outcome because it is unknown what would be required to reschedule the workloads of a given node.
Before: Unpredictable Failover
Figure 20: Kubernetes cluster default settings
Figure 20 shows a cluster that has not been configured beyond the default kubeadm configuration. While it is possible to configure a monitoring tool to observe the current utilization of nodes within your cluster, a lack of requests and limits makes it difficult to tell whether or not the cluster could accommodate a node failure.
After: Predictable Failover
Figure 21: Kubernetes cluster with Node Allocatable Constraints configured
On the other hand, a cluster with bounded resource consumption makes this task relatively simple. Monitoring tools may be configured to consume the cluster’s resource requests, limits, eviction thresholds, kube reserved and system reserved settings. With these values known, it is possible to configure an alert that will warn a cluster manager when the cluster will no longer be able to tolerate a node failure. Figure 21 is a visualization of this concept with a node in its most general form, with a resource’s allocatable capacity limited by node allocatable constraints. This illustration applies to CPU, memory and ephemeral storage.
Calculating Max Utilization
Similar to calculating whether or not a cluster could afford a node failure, it is also possible to calculate the maximum utilization of each node such that the cluster could tolerate a node failure. Note that this calculation is only an estimation, and does not take into account scheduling complexities such as affinity. The broader point here is that having well-defined limits and requests allows us to be proactive in reasoning about different failure scenarios.
Estimate Function
Figure 22: Simple function for maximum utilization of nodes while allowing for 1 failure, where n represents the number of nodes in a cluster
A simple version of calculating this value is shown in Figure 22, with sample input and output shown in Table 2. Calculating maximum utilization with this function makes the following assumptions:
- allocatable constraints (eviction threshold, kube & system reserved) == 0
- number of failures is 1
| # of nodes (n) | maxUtilization(n) |
|---|---|
| 2 | 50% |
| 3 | 66% |
| 10 | 90% |
Full Function
Maximum utilization may also be calculated without making any of the previous assumptions. Figure 23 shows how to calculate maximum utilization while also taking into account the number of node failures, f, and node allocatable constraints (summed up across all nodes), c. Table 3 shows example input and output for this function.
Figure 23: Full function for maximum utilization of nodes while accounting for an arbitrary number of node failures (f) and node allocatable constraints.
| # of nodes (n) | max # of node failures | node allocatable constraints | max utilization of nodes |
|---|---|---|---|
| 2 | 1 | 0 | 50% |
| 3 | 1 | 0 | 66% |
| 10 | 1 | 0 | 90% |
| 2 | 1 | 0.2 | 40% |
| 3 | 1 | 0.3 | 56% |
| 10 | 2 | 0.5 | 75% |
Tying it All Together
The beginning of this document categorized disruptions into two categories: involuntary and voluntary. By now, it should be clear how each of the constructs discussed in this document mitigate the risks presented by these disruptions.
Before Tuning
Figure 20 provides a good visual for the risks that are present in an untuned Kubernetes cluster. This cluster is not resilient to involuntary disruptions because its workload and daemon resource consumption is unbounded, putting nodes at risk of instability and causing failover to be unpredictable. During voluntary disruptions such as scaling or node draining, there are no PDBs in place to protect stateful or high-priority applications from losing high-availability. Scheduling is inefficient as it is unaware of pod priority, affinity, anti-affinity requirements. Overall, its behavior is not well-defined and the only way to ensure stability is by minimizing utilization.
After Tuning
The cluster shown in Figure 21 is a good visual for a tuned cluster. It is resilient to involuntary disruptions because workload and daemon resource consumption is bounded, which mitigates the risk of node instability also results in predictable failover scenarios. During voluntary disruptions such as scaling or node draining, PDBs, affinity, and anti-affinity now help applications maintain high-availability. Scheduling is efficient as it is aware of pod priority, affinity and anti-affinity requirements. Overall, stability and utilization of the cluster is optimized.
Refocusing on Bigger Problems
Prior to tuning your cluster, it will be exposed to a number of risks that detract from the benefits Kubernetes has to offer. A tuned cluster gives you peace of mind and an ability to focus on broader architectural tradeoffs such as those between utilization, fault tolerance and scheduling complexity.
Utilization vs. Fault Tolerance
How many nodes can your environment tolerate losing? This depends on many factors including your application’s service-level-agreement (SLA), disruption tolerance and other organizational requirements. It is a complicated question to answer, but with a tuned cluster it is much easier to approach. As discussed, bounded resource consumption allows you determine the max utilization of your nodes based on your fault tolerance requirements.
Utilization vs. Scheduling Complexity
If your workloads have relatively simple resource requirements, the scheduler’s job will be straightforward and you may be able to increase the utilization of your cluster by scaling the number of nodes down. On the other hand, complex resource requirements will complicate scheduling. This may be may be remedied by adding capacity to the cluster, which reduces cluster utilization.
Testing
Kind is a tool for running clusters locally using Docker containers as nodes, and may be used to familiarize with configuring the kubelet parameters discussed in this document. You may also experiment with application-level parameters (those discussed in the Application Owner section) upon cluster creation. Follow the getting started guide with the following configuration to deploy a kind cluster with default node allocatable constraints:
kind: Cluster
apiVersion: kind.sigs.k8s.io/v1alpha3
kubeadmConfigPatches:
- |
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
metadata:
name: config
maxPods: 110
# systemReserved:
# memory: "500Mi"
# kubeReserved:
# memory: "500Mi"
evictionHard:
memory.available: "100Mi"
imagefs.available: "15%"
nodefs.available: "10%"
nodefs.inodesFree: "5%"
- |
apiVersion: kubeadm.k8s.io/v1beta2
kind: InitConfiguration
metadata:
name: config
nodeRegistration:
kubeletExtraArgs:
"housekeeping-interval": "10s"
"enforce-node-allocatable": "pods"
nodes:
- role: control-plane
- role: worker
To enforce system or kube reserved flags, be sure to configure your cgroup driver and update the enforce-node-allocatable.


| Fig 1 |
Rainfall, PET and average soil water content during ENSO. Su ... |
| Fig 2 |
Standardized precipitation-evapotranspiration index on 12-mo ... |
| Fig 3 |
Yield per farm based on the number of pods per main harvest. ... |
| Fig 4 |
Cocoa production in Brazil, Bahia, Para and Barro Preto sinc ... |


"Produce a deep network capable of detecting and localizing nearby, potentially occluded pedestrians under reasonable lighting conditions, that can be integrated into a mobile robot (eg. Tegra X1 chip)"
Train a large network as teacher model and transfer the knowledge to smaller student model [Hinton, 2015]
Estimate teacher confidence by enable dropout at test time [Yarin Gal, 2015], and maximize the log-likehood of multivariate Gaussian distribution
Increase the dimensionality of teacher's guidance by adding extra fully-connected layer to allow better representation of teacher output distribution
Use Aggregate Channel Features [Dollar, 2014] as hand-designed feature to increse the student model complexity without introducing significant overhead
| Models | Log-avg MR | Drop |
| Teacher | 17.5% | 0.0% |
| Student | 24.5% | 7.0% |
| Student+KD | 24.8% | 7.3% |
| Student+KD+Conf | 23.7% | 6.2% |
| Student+KD+Hint | 23.1% | 5.6% |
| Student+KD+Conf+Hint | 22.4% | 4.9% |
| Student+KD+ACF | 25.2% | 7.7% |
| Student+KD+ACF+Conf+Hint | 23.4% | 5.9% |
| Models | Params | Memory | Speed |
| ResNet-200 (Teacher) |
63 M | 4.93 GB | 24 ms |
| ResNet-18 | 11 M | 612 MB | 3 ms |
| ResNet-18-Thin | 2.8 M | 308 MB | 3 ms |
| ResNet-18-Small | 0.16 M | 240 MB | 3 ms |


Event Location:
K-Force
1001 East Palm Ave
Tampa, Florida
Abstract:
Let's face it, reading and writing data with SQL Server can be expensive and has scaling this type of architecture has its implications that need to be considered upfront. This is one of the reasons Microsoft has included caching within its future AppFabric Framework. Caching is not a new methodology because we can use it currently in applications built on top of ASP.Net out of the box, however there are still scaling issues that AppFabric Caching (ACF), formerly Velocity addresses. As database developers, it is important to identify with new trends that may affect database integration and this presentation does just that. First we will learn the basics of AFC, how to install, how to scale, and how data driven solutions can benefit from it.
Speaker(s): Bayer White,
Abstract:
SQL Server stores its execution plans as XML in dynamic management views. The execution plans are a gold mine of information. From the whether or not the execution plan will rely on parallelism to what columns are requiring a key lookup after a non-clustered index seek. Through a the use of XML this information can be available at your finger tips to help determine the value and impact of an index and guide you in improving the performance of your SQL Server databases. Prerequisites Understanding of basic T-SQL coding Understanding of basic XQuery statements Goals: 1. Discuss information available in an execution plan 2. Demonstrate use of XQuery to query execution cache 3. Demonstrate methods to performance tune
Speaker(s): Jason Strate,
Abstract:
Should you be networking? In this session we'll talk about why you should be building a network now, how to build it, and how to keep track of and quantify your network. Along the way we'll talk about the most common social networks, why you should consider blogging, and some exercises you can do to strengthen your networking skills.
Speaker(s): Andy Warren,
Abstract:
In this session I will explain SQL Server Data compression (Page and Row), provide scripts and tips that will help you identity the compression state that should be configured in your Warehouse environment and also provide demo scripts showing you how to configure compression at the Table and Index level.
Speaker(s): Patrick LeBlanc,
Abstract:
Using Analysis Services, ASP.NET, AJAX callbacks for refresh, Dundas grids and charts, and Notification Services for alerts, this session will show how to integrate a variety of MS technologies to create a state-of-the-art dashboard system. This particular dashboard implementation is currently in use by Norfolk Southern railroad to monitor intermodal shipments. The concepts could be applied to monitoring any operational system. It also shows how cubes can be used for more than just decision support.
Speaker(s): Mark Landry,
Abstract:
In this session I will go over some of the techniques that I have used to implement database partitioning in a 2 TB OLTP database. This session will be about now that you have decided to use partitioning how do you determine what partition key to use? If my table is using multiple search criteria at different times how do I choose a partitioning key? What tables should I Partition? How should my partitions be stored?
Speaker(s): Elijah Baker,
Abstract:
We will take a look at SQL Service Broker, the built-in asynchronous messaging subsystem provided with SQL Server. We will examine new terminology as well as get a grounding in how we can setup and use Service Broker for messaging applications. We live in an increasingly interconnected world and having a system that can handle intermittent connections and asynchronous processing can solve many business problems. And if MySpace can use it to pass hundreds of millions of messages around their system per day, it can probably do whatever you need it to do as well! Plenty of code in this presentation too.
Speaker(s): Kevin Boles,
Abstract:
With the proliferation of ORM Tools like Linq To SQL, NHibernate, there has been a move to no longer use stored procedures for Data Access, I personally disagree. This will be a professional and polite open discussion starting with why I believe stored procedures are the best way to access data in SQL Server. Alternate view points welcome.
Speaker(s): Jack Corbett,
Abstract:
The start of a new year offers us the opportunity to “take stock” of what may or may not be helping us to achieve our personal and professional goals. One thing we may forget to assess is our “professional brand”. Your professional brand can help you to distinguish and position your personal portfolio of experience, skills and knowledge as unique and of value to customers and in the marketplace. This session looks at five actions to take that align your professional brand with your career goals, and can help your clients, peers, and managers see the tangible and intangible benefits of working with you.
Speaker(s): Patricia (Pat) Baxter,
Abstract:
Janis Griffin has over 20 years of DBA experience including design, development and implementation of many critical database applications. Prior to Confio, Janis held DBA positions in the Telecom Industry (15 yrs), working with both real-time network routing databases and OLTP business to business applications. Janis was Principal Architect and Sr. Manager, mentoring other DBAs on best practices in database performance tuning.
Speaker(s): Janis Griffin,
Abstract:
In this session I will demonstrate MDX with SQL Analysis Services. This session will demonstrate the analytic powers incorporated into the SQL AS Engine using MDX. I will start with basic concepts of MDX and move to more Advanced calculations.
Speaker(s): Michael Mollenhour,
Abstract:
Common Table Expressions (CTE) aren’t as common as their name implies. CTEs are often seen as a secret part of the dark art of recursion. This session will explore CTEs to show how they can be extremely useful in improving performance and legibility of T-SQL code. And, of course, we will look at their use in returning recursive data. Prerequisites Understand of basic T-SQL coding Goals: Provide an understanding of the purpose and use of CTEs for recursion and derived tables Define the pro’s and con’s to using CTEs in recursion and for derived tables Demonstrate real-world examples detailing methods for using CTEs to solve coding challenges
Speaker(s): Jason Strate,
Abstract:
Learn all you wanted to know about index design but were afraid to ask. This session focuses on physical index structures as well as how the server chooses indexes. Note: Join optimization is a separate session
Speaker(s): Jeffrey Garbus,
Abstract:
This session is designed as a lead-in to the session by Scott Klein. It defines what XM is and how it differs from regular HTML, It looks at how to define data type variables and columns in SQL to store XML, how to output XML from existing table structures. It also covers how to use OPENXML, how to create and use your own namespaces, and the difference between typed XML and untyped XML.
Speaker(s): Michael Antonovich,
Abstract:
Participate in an architecture review showcasing the use of SQL Server 2008 Spatial features and the filestream data. The session will focus on a pre-defined solution architecture using SQL Server 2005 with pure relational data and after a brief introduction of new features in SQL Server 2008, changes will be presented and discussed with the group, culminating in a new architecture.
Speaker(s): Telmo Sampaio,
Abstract:
Microsoft SQL Server Integration Services (SSIS) users who are writing too much complex code to transform data, struggling with application performance or having trouble integrating diverse data sources will benefit from learning about the expressor semantic data integration system -- an affordable, enterprise-class alternative to SSIS. They will learn how American Tower improved the data loading times for its data warehouse and enabled its developers to perform complex data transformations in a single process by migrating from Microsoft SSIS to expressor.
Speaker(s): Michael Ruland,
Abstract:
Hear how Access 2010 and SharePoint 2010 can be used to better manage your Access applications, reducing the load on your SQL Server. SharePoint 2010 manages security, backup, and deployment of the Access aps, and makes it possible to use the Access ap in the browser without having Access on the client machine and in untrusted mode. And because of the way Access now caches, it becomes a tool of choice for large number of records queries and reports (40,000-160,000 records), reducing the load on your SQL Servers. Finally, see a tool for finding the Access applications in your environment so you can prioritize making them more managed.
Speaker(s): Kathy Malone,
Abstract:
SQL Server replication allows DBAs to distribute data to various servers throughout an organization. Some of the primary reasons to employ replication include load balancing, offline processing redundancy. Transactional replication in particular can offer a very flexible solution where data frequently changes. This session will discuss the basics of planning and implementation of a solid transactional replication solution.
Speaker(s): Troy Gallant,
Abstract:
In this session we will discuss SQL Azure at a high level including development lifecycle, production, security, auditing and general limitations.
Speaker(s): Herve Roggero,
Abstract:
In this session we will learn to perform several everyday DBA tasks like backing up user databases, scripting table objects and evaluating disk space usage with PowerShell. For each task we will explore the benefits of using PowerShell over the standard method. Only a basic understanding of PowerShell or DOS is needed. This session should serve as a good introduction to PowerShell for database users. The goal is to get data professionals feet wet using PowerShell.
Speaker(s): Aaron Nelson,
Abstract:
Overcome the barriers of traditional training and seminars with this Quick Start to building a cube. This all demo session will get you started and answer many questions you have about building cubes the right way, the first time.
Speaker(s): Adam Jorgensen,
Abstract:
You need to know how SQL Server works internally if you want to design the effective solutions. This session will give the overview of how SQL Server stores data internally; what criteria query optimizer uses when choose the index and provide some guidelines how to design tables and indexes to improve the performance of the database solutions.
Speaker(s): Dmitri Korotkevitch,
Abstract:
The session will introduce the attendees to the basics of Data Mining and Predictive analysis. It will go over the basic building blocks of SQL 2008 Data Mining Engine and will provide an example of Data Mining project lifecycle.
Speaker(s): Vikas Hawaldar,
Abstract:
This session will get you past the learning curve of SSIS. Brian covers creating an end to end package that covers many of the concepts in SSIS. He covers, looping over a set of files, processing each file and then archiving. You won't want to miss this if you're new to SSIS.
Speaker(s): Brian Knight,
Abstract:
EVERY SQL Server uses tempdb, many of them extensively. Suboptimal configuration is a leading cause of poor performance. We will cover how to have an optimal configuration for your environment and also how to effectively monitor various tempdb metrics.
Speaker(s): Kevin Boles,
Abstract:
In this session, you’ll learn how to use a series of free and pay components in your tool belt to improve the speed of your SSIS development. You’ll learn how to code packages faster with templates in BI xPress and how tasks and transforms built into Task Factory can take hours off your SSIS runtime.
Speaker(s): Brian Knight,
Abstract:
In this session I'll show you how SSIS can use a scripted task or execute task to encrypt or decrypt a file. All examples will be in C#..
Speaker(s): Scott Gleason,
Abstract:
This session will cover the basics the different types of execution plans, how to generate them, and how to read them.
Speaker(s): Nathan Heaivilin,
Abstract:
In this session, you’ll learn how to load a data warehouse using SQL Server Integration Services (SSIS). You'll see a battle between two SSIS experts (Brian Knight and Adam Jorgensen), attempting to load the data warehouse the best way. You'll see varying architectures and best practices from each of the presenters and you decide who wins the Iron Chef competition.
Speaker(s): Brian Knight,
Abstract:
Learn about the major changes in clustering in recent SQL and Windows releases and how clustering is something you can implement that will actually make your work life easier.
Speaker(s): Geoff Hiten,
Abstract:
In this sesssion we will look at performing common data loading tasks with Powershell. A basic understanding of PowerShell is helpful, but not necessary. Specific topics covered include importing structured files, XML, WMI objects and ADO.NET data sources.
Speaker(s): Chad Miller,
Abstract:
On my blog I've started a project called SQL University aimed at folks looking to learn SQL Server from the ground up. This session will start at ground level tasks and resources all database professionals should know. This session is aimed at entry-level folks but anyone is welcome to attend to sharpen up their basic skills and resources!
Speaker(s): Jorge Segarra,
Abstract:
Cloud computing is gaining momentum. Knowing how to develop applications for the cloud is important. This session will discuss how to develop applications with SQL Azure, and It will focus on two areas when developing application for SQL Azure, the .NET side and the SQL side.
Speaker(s): Scott Klein,
Abstract:
Become a better SQL coder by learning the most common pitfalls in the SQL language. Both inexperienced and experienced SQL developers and DBAs can get caught by many of these. Practical examples and internal logical processing explanation will help you understand why mistakes happen and how to develop good SQL coding practices to avoid them.
Speaker(s): Plamen Ratchev,
Abstract:
Confio Software (Janis Griffin, Sr. DBA Product Architect) and Soaring Eagle Consulting (Jeff Garbus, Principal) will conduct a demonstration of “Real-World Performance Tuning” using the Ignite Suite from Confio. In this demonstration and discussion, Janis Griffin and Jeff Garbus will show the audience how using Response-Time Analysis and Wait-Types in SQL Server to quickly diagnose and identify performance bottlenecks in SQL Server 2000,2005, and 2008. Ignite may also be used for cross-platform monitoring and performance tuning on Oracle, Sybase and DB2-LUW.
Speaker(s): Janis Griffin,
Abstract:
In this session Mike shows parameters in many different ways including stored procedure, cascading, Default Values, Available Values, Multi value with the Split Functions in Stored Procedures.
Speaker(s): Mike Davis,
Abstract:
Database Hardening via PowerShell. I will demonstrate how I use PowerShell to handle the issues encountered in a Fortune 50 corporate environment that has over 500 database servers and 3600 databases.
Speaker(s): Ronald Dameron,
Abstract:
Utilizing only T-SQL and algebra, I will engage the attendees in a discussion of teasing trends out of data buried within SQL Server, without having to learn the intricacies of Data Warehousing and MDX Querying. It is my hope that my methods can be used and expanded upon in your field, and I invite those who use SQL Server in any environment to come join the discussion.
Speaker(s): David Taylor,
Abstract:
Event Notifications are a hidden gem in SQL Server 2005, just waiting to provide you with real time information about problems inside of SQL Server. This session will provide a brief overview of the Service Broker components used by Event Notifications and then dive into how to build a monitoring solution for common problems in SQL Server like blocking and deadlocks that capture the needed information for troubleshooting in real time and provide email notification that a problem exists.
Speaker(s): Jonathan Kehayias,
Abstract:
Many people live by the motto “If it’s not broken, don’t fix it”. But if you believe that you are missing all enhancements introduced in newer versions of SQL Server (2005/2008). These new features can help you develop better solutions with improved performance, scalability, and maintainability. Learn how to craft a better query using the new MERGE statement, ranking functions, and more. Practical examples with tips and tricks.
Speaker(s): Plamen Ratchev,
Abstract:
This session reviews rewriting a bad chunk of data migration code. Your speaker wrote the original code at 1:30 am, rewrote it with disgust at 2am, and wrote it nicely the next evening. We will review why the dozens of reqasons the first 2 passes are bad, followed by some firm coding recommendations.
Speaker(s): Jeffrey Garbus,
Abstract:
An overview of the new spatial geography data types in SQL Server 2008. Following the overview will be a demonstration of creating queries with spatial data as input and results. Finally, we will wire up a real world example into Bing Maps using ASP.Net.
Speaker(s): Michael Stark,
Abstract:
Most developers would agree that every SSIS solution will have the same fundamental outline. A basic framework will expedite the process by handling the common tasks between the systems while allowing the developer to concentrate on the task at hand. This framework will consist of many items, including but not limited to setting up package configurations, logging, audit trails, error handling, naming standards, etc. This session will present an example framework which can be used as the basis for future SSIS Package. In response to previous comments, the majority of the material will be presented via demos.
Speaker(s): Eric Wisdahl,
Abstract:
What are SCDs? How do I manage them? SSIS Provides an SCD Wizard which can make your life easier. It also has problems which we'll show you how to work around.
Speaker(s): Christian Loris,
Abstract:
We will be learning an overview of this powerful new feature in SQL 2008 and how you can leverage it to help manage your existing SQL environment. This will include plenty of demos, best practices and QA so by the end you should be able to walk away ready to take control of your SQL Servers!
Speaker(s): Jorge Segarra,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: https://www.linkedin.com/in/wadamjorgensen/
Contact: http://www.pragmaticworks.com
As President of Pragmatic Works Consulting Adam drives market strategy, sales, partnerships, implementation and thought leadership. He has over 15 years of experience helping companies use their data to fuel their growth. Adam has been wowing audiences around the world for over a decade. He has delivered hundreds of sessions, published over a dozen books and hundreds of online videos and webinars on data and cloud topics. His passion is growing companies and mentoring leaders and companies to help them achieve their dreams.
LinkedIn: https://www.linkedin.com/profile/view?id=176471amp;trk=nav_responsive_tab_profile
Contact: http://mssqlperformance.blogspot.com/
Jeff has been consulting on and performing technical training for MS SQL Server since 1989, Version 4, on OS/2. Since then, he has worked extensively with each release of the product, specializing in performance and tuning, from concept through legacy system, on systems of all sizes, from small start-up company applications to multi-terabyte data warehouses. In addition to hands-on consulting, he speaks at SQLSaturdays several times/year, has a youtube channel with free training, and has written 20 books on database management systems. His latest book is "Transact SQL the Definitive Guide."
LinkedIn: http://www.linkedin.com/pub/janis-griffin/0/914/aba
Janis Griffin has over 30 years of DBA/database experience including design, development and implementation of many critical database applications. Before coming to Quest Software, Janis primarily worked in the Telecom/Network Industry, working with both real-time network routing databases and OLTP business to business applications. Janis also held positions as a Principal Architect and Senior Manager, mentoring other DBAs on best practices in database performance tuning.
Contact: http://feeds2.feedburner.com/StrateSql
Jason Strate, Digineer Inc, is a database architect and administrator with over 12 years of experience. In July 2009, he was awarded Microsoft MVP (Most Valuable Professional) for SQL Server. Jason is a SQL Server MCITP and participated in the development of Microsoft Certification exams for SQL Server 2008. He is actively involved with MN PASS chapter and is currently serving as the Program Director. Jason enjoys speaking and has presented for SSWUG, PASSMN, and at the PASS Summit.
Scott Klein is a Microsoft SQL Server MVP with a passion for all things SQL. He has authored a number of books and articles, including Professional SQL Server 2005 XML and Professional LINQ, both by Wrox. He is a frequent speaker at user groups, code camps, and SQLSaturday's and is currently digging into SQL Azure and Visual Studio 2010 as he writes a book on the ADO.NET 4.0 Entity Framework.
LinkedIn: http://www.linkedin.com/in/mikedavissql
Contact: http://MikeDavisSQL.com
Mike Davis, MCITP, is a Consulting Team Lead at Pragmatic Works. He is an author with books covering Business Intelligence and SSIS. Mike is an experienced speaker and has presented at many events such as several SQL Server User Groups, Code Camps, SQL Server Launches, SQLSaturday, and SQL Rally. Mike is an active member at his local user group (JSSUG) in Jacksonville, FL.
LinkedIn: https://www.linkedin.com/profile/view?id=176471amp;trk=nav_responsive_tab_profile
Contact: http://mssqlperformance.blogspot.com/
Jeff has been consulting on and performing technical training for MS SQL Server since 1989, Version 4, on OS/2. Since then, he has worked extensively with each release of the product, specializing in performance and tuning, from concept through legacy system, on systems of all sizes, from small start-up company applications to multi-terabyte data warehouses. In addition to hands-on consulting, he speaks at SQLSaturdays several times/year, has a youtube channel with free training, and has written 20 books on database management systems. His latest book is "Transact SQL the Definitive Guide."
LinkedIn: http://www.linkedin.com/in/jdsegarra
Contact: http://sqlchicken.com
Jorge Segarra is a senior consultant for Microsoft (Premier Support for Developers) and a former SQL Server MVP. Jorge has co-authored titles including "SQL 2008 Pro Policy-Based Management" and "SQL Server 2012 Bible" .
Contact: https://www.sqlskills.com/blogs/jonathan
Jonathan Kehayias is a Principal Consultant and trainer with SQLskills, and has been recognized as a Microsoft Data Platform MVP for over 10 years, and was the youngest person ever to achieve the Microsoft Certified Master – SQL Server certification. He has presented at numerous conferences including PASS Summit and SQL Rally, SQLBits, VMware Open Forum, SQLintersection, and multiple SQLSaturdays around the world. As a performance tuning and high availability expert for SQL Server, Jonathan has architected and implemented complex systems and solutions for some of the worlds most challenging workloads.
Kathy Malone has used Acces since version 1.0, SharePoint since the 2007 version, and was excited to hear at the SharePoint Conference in 2009 that there were 5 sessions on how the then-pending Access 2010 would integrate with SharePoint 2010. She had the opportunity to visit the Access team in Dec 2009, was active in the Office 2010 CTP/Beta, and continues to be explore how the 2 tools work together.
LinkedIn: https://www.linkedin.com/in/scgleason
Scott is a vice president of the Jacksonville FL SQL Users group with over 10 years experience as a database administrator, working in both Healthcare and Financial industries. He is both Energetic and animated teacher. His passion is learning new technology and sharing his Sql experiences (the good and the lessons learned) with others.
LinkedIn: https://www.linkedin.com/in/michaelpantonovich?
Contact: http://sharepointmike.wordpress.com
Michael Antonovich is the assistant director of Web and Technology Services in the Communications Division for Orange County Public Schools in Orlando, FL, where he manages the Internet and intranet infrastructure. He has published seven books, ranging from an Apple II User Guide to Office and SharePoint 2010 User's Guide. His blog has focused mainly on PowerPivot and Power BI, but for the last year Mike has taken a break to pursue some other activities. He hopes to restart his blog later this year focusing more on style and presentation. Mike has used SQL Server since 1998 and, for the past 7 years, has been promoting SSAS, PowerPivot, and Power BI for the masses.
Vikas is BI Architect at Idea Integration. He has 12 years of experience in Business Intelligence. He has spoken into several SQLSaturday sessions.
Contact: http://www.actsoft.com
Dmitri Korotkevitch is Director of Development at Actsoft - Tampa based company developing GPS Tracking and Mobile Management solutions. Back-end database handles around 2000 TPS during the peak time. Dmitri holds MCPD and MCITP - Sql Server 2005 2008 Database Developer and 2008 Database Administrator certificates.
Michael Stark has been developing software since 1992. He has worked for both large and small companies. He has worked in a variety of platforms and environments. He prefers the newer technologies and enjoys learning new skills and applying them as solutions to existing processes. He prefers client facing software development projects. He gets personal satisfaction with build products that make business life easier for the end user. Mr. Stark is originally from Miami, Florida and currently resides in Tampa, Florida. In between the two he has live in Atlanta, Detroit, Deland, and Madrid Spain.
Elijah Baker is an 18 year veteran using SQL Server with the past 10 years being focused mostly on development. He has worked in all levels of SQL Server development from the JR developer up to the lead and architect positions. Currently he is working a PaySpan Inc. which processes medical payments and data. Elijah has become an expert on Partitioning to allow PaySpan’s largest database, 8TB+ 10 billion+ rows, to continue growing as needed without any significant performance degradation.
LinkedIn: http://www.linkedin.com/in/jdsegarra
Contact: http://sqlchicken.com
Jorge Segarra is a senior consultant for Microsoft (Premier Support for Developers) and a former SQL Server MVP. Jorge has co-authored titles including "SQL 2008 Pro Policy-Based Management" and "SQL Server 2012 Bible" .
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://www.linkedin.com/pub/janis-griffin/0/914/aba
Janis Griffin has over 30 years of DBA/database experience including design, development and implementation of many critical database applications. Before coming to Quest Software, Janis primarily worked in the Telecom/Network Industry, working with both real-time network routing databases and OLTP business to business applications. Janis also held positions as a Principal Architect and Senior Manager, mentoring other DBAs on best practices in database performance tuning.
Contact: http://feeds2.feedburner.com/StrateSql
Jason Strate, Digineer Inc, is a database architect and administrator with over 12 years of experience. In July 2009, he was awarded Microsoft MVP (Most Valuable Professional) for SQL Server. Jason is a SQL Server MCITP and participated in the development of Microsoft Certification exams for SQL Server 2008. He is actively involved with MN PASS chapter and is currently serving as the Program Director. Jason enjoys speaking and has presented for SSWUG, PASSMN, and at the PASS Summit.
Contact: http://pratchev.blogspot.com
Plamen is an SQL Server MVP specializing in relational database applications analysis, implementation, and tuning. His particular interest is in design patterns, performance and optimization. In the past two decades he has worked in different roles as database developer and architect in medium and large scale enterprise applications. He has been involved on projects utilizing DB2 and Oracle, but his main passion is SQL Server, which he started using at version 4.2. Plamen has master's degree in computer science with specialization in algorithms and compliers. He enjoys sharing his experience with user groups and at various conferences.
Contact: http://www.bidn.com/people/brianknight
Brian Knight, a SQL Server MVP, MCSE, and MCDBA, is the owner and founder of Pragmatic Works. He is also the co-founder of SQLServerCentral.com, BIDN.com, and SQLShare.com. Brian runs the local SQL Server users group in Jacksonville (JSSUG), is a contributing columnist at several technical magazines, and does regular webcasts at PragmaticWorks.com. He is the author of 15 SQL Server books and a frequent speaker at conferences such as PASS Summit, SQL Connections, TechEd, and many Code Camps.
Just a DBA who wants to give back to the community in the way they have given to me and helped my development over the years.
Contact: http://dyfhid.wordpress.com
David is an DBA/Developer for a private educational institution in New Hampshire. David has five years of experience learning and administering SQL Server and more recently developing BI solutions using SSIS. Having earned both his MCTS and MCITP DBA certifications for SQL Server 2008, he still considers himself a beginner sharing with other beginners.
Contact: http://pratchev.blogspot.com
Plamen is an SQL Server MVP specializing in relational database applications analysis, implementation, and tuning. His particular interest is in design patterns, performance and optimization. In the past two decades he has worked in different roles as database developer and architect in medium and large scale enterprise applications. He has been involved on projects utilizing DB2 and Oracle, but his main passion is SQL Server, which he started using at version 4.2. Plamen has master's degree in computer science with specialization in algorithms and compliers. He enjoys sharing his experience with user groups and at various conferences.
Contact: http://geekswithblogs.net/hroggero
Herve Roggero, Microsoft Azure MVP, is the founder of Enzo Unified (www.enzounified.com). Herve’s experience includes software development, architecture, database administration and senior management with both global corporations and startup companies. He holds multiple certifications, including an MCDBA, MCSE, MCSD. He is a Pluralsight author, runs the Azure Florida Association, and co-authored two Azure book with Apress.
LinkedIn: https://www.linkedin.com/in/ericwisdahl
Eric Wisdahl is a computer engineer working in the database field. He has held multiple roles and positions in e-commerce, marketing and insurance industries. Currently, he is working as a database administrator in a development role for an e-commerce company. Eric Wisdahl does not like writing about himself in the third person. It is kind of creepy.
Contact: https://sqlandy.com
Andy Warren is a SQL Server consultant and trainer based in Orlando, FL. Focusing on administration, performance tuning, and SQL Server patterns and practices, he’s been a SQL Server MVP since 2008. Andy served two terms on the PASS Board of Directors, was a founding principal in SQLServerCentral, and created both the SQLSaturday and SQLRally event models.
Contact: http://sqldownsouth.blogspot.com/
Patrick LeBlanc is currently a BI Consultant for Pragmatic Works. I have 9 years experience with developing and deploying database solutions. Patrick is a regular speaker at SQLSaturday, User Groups and SQL Lunches. He is also the founder of TSQLScripts.com and SQLLunch.com. Patrick is also the President of the Baton Rouge Area SQL Server User Group.
LinkedIn: http://www.linkedin.com/in/rdameron
Contact: http://RonaldDameron.com
Ronald Dameron is The Only DBA at a small software company building planet-scale mobile resource management software. He has over 20 years IT experience on a variety of platforms. His current interests are Azure, PowerShell, SQL Server 2016 and Linux. He was a PASS Summit 2015 Speaker Idol contestant and has spoken at SQLSaturday Tampa, Orlando, South Florida, and the Tampa and Orlando SQL User groups. He has recently earned the Competent Communicator Award from Toastmasters International. He is most active on Twitter as @RonDBA.
Great guy!
Chad Miller is a Senior Manager of Database Administration at Raymond James Financial. Chad has worked with Microsoft SQL Server since 1999 and has been automating administration tasks using Windows Powershell since 2007. In his spare time he is the Project Coordinator/Developer of Powershell-based Codeplex project SQL Server PowerShell Extensions (SQLPSX). Chad leads the Tampa Powershell User Group and is also a frequent speaker at SQL Server users groups, SQLSaturdays and Code Camps.
Contact: http://www.flowfocus.com
Bayer White has been developing enterprise solutions for the past 12 years using .Net Technologies. Since the first beta of the .Net Framework 3.0, his focus has been mastering Business Process Management (BPM) using Windows Workflow Foundation (WF). He is known within the Florida developer community by speaking at Florida Code Camps, blogging and writing articles focused on WF. He has also spoken at various conferences such as PASS, DevConnections, VSLive and MDC.
LinkedIn: http://www.linkedin.com/in/jackcorbett
Contact: http://www.wisemanorwiseguy.com
JJack Corbett began working with SQL Server, Access, and VB in 1999, when he served an apprenticeship with a good friend who was the software development manager at the local paper mill. He found his niche and has concentrated on SQL Server development and administration since late 2000. He has worked with SQL Server through version 2017 and was a Microsoft Data Plaform MVP from October 2011 to October 2016. Jack is passionate about helping companies architect, design, and develop high performance applications based on the Microsoft Data Platform. He also has a passion for seeing database developers get the core application code (the database) protected under source control. Jack has presented at many user groups and SQLSaturday even
Michael Ruland is director of field engineering at expressor software. Michael has more than 30 years’ IT experience, including more than a dozen focused on constructing and maintaining large, complex data warehouse and decision support structures. He has worked as a Global Technical Architect in IBM’s Advanced Technology Group, in addition to application programming, systems programming, and various sales and engineering positions with Amdahl, Informix, Prism Solutions, Ardent and Ascential.
Mark Landry has over thirty years of experience in software development. He has been an independent software consultant for fifteen years specializing in object-oriented design and programming, relational and multidimensional database design, and data warehousing. He is considered a regional expert in Analysis Services. Mr. Landry holds Bachelors and Masters Degrees in Computer Science.
LinkedIn: http://www.linkedin.com/in/thesqlguru
Kevin Boles is a SQL Server expert, working exclusively with the product since v6.5. With over 25 years of database experience and over 45,000 man hours of SQL Server engine experience, he holds many related certifications, is an MCT and was a SQL Server MVP from 2007 to 2012. Kevin has been a very successful independent consultant for over 20 years. His passion is the relational engine, especially designing, building, analyzing and tuning high-performance database applications.
Contact: http://www.troygallant.com
Troy has been a SQL Server professional for over 18 years, filling various roles as analyst, developer, and for the last decade, DBA. As a regular speaker at SQLSaturdays up and down the east coast, he’s taught on a multitude of topics from disaster recovery to performance tuning to professional development. Currently residing in Jacksonville once again, he just got back from two years as Sr. DBA for the EDW of a major international insurance company in New York City.
Contact: http://www.bidn.com/people/brianknight
Brian Knight, a SQL Server MVP, MCSE, and MCDBA, is the owner and founder of Pragmatic Works. He is also the co-founder of SQLServerCentral.com, BIDN.com, and SQLShare.com. Brian runs the local SQL Server users group in Jacksonville (JSSUG), is a contributing columnist at several technical magazines, and does regular webcasts at PragmaticWorks.com. He is the author of 15 SQL Server books and a frequent speaker at conferences such as PASS Summit, SQL Connections, TechEd, and many Code Camps.
Contact: http://www.patriciabaxter.com
Pat has served as a leader in global firms as SYKES, UNISYS, Siebel, Deloitte Touche Consulting, Citigroup, Prudential and AchieveGlobal. Her career is focused on helping to attract, develop and retain talent, believing “Without the people, it’s an empty building.” She serves on several university based boards including at the University of Tampa and USF. Pat holds a B.S., M.S., and post graduate degree, all in educational leadership and is a doctoral student in Leadership at Argosy.
Contact: http://www.bidn.com/people/brianknight
Brian Knight, a SQL Server MVP, MCSE, and MCDBA, is the owner and founder of Pragmatic Works. He is also the co-founder of SQLServerCentral.com, BIDN.com, and SQLShare.com. Brian runs the local SQL Server users group in Jacksonville (JSSUG), is a contributing columnist at several technical magazines, and does regular webcasts at PragmaticWorks.com. He is the author of 15 SQL Server books and a frequent speaker at conferences such as PASS Summit, SQL Connections, TechEd, and many Code Camps.
Contact: http://www.implementsivillage.net
Christian Loris is one of the group leaders from the Space Coast SQL User Group. He is a Software Engineer currently working in Data Warehousing, BI and BizTalk middleware at Harris Corporation. In the past Chris has worked as an ASP.Net developer, Engineering Manager, Professional Services Engineer, Test Engineer and a Technical Writer.
LinkedIn: http://www.linkedin.com/pub/geoff-hiten/1/b54/6a3/
Microsoft MVP Geoff Hiten is a Principal SQL Server consultant for Intellinet.#160; Geoff began working with SQL Server in 1992 with version 4.2 and has used every version since.#160; He specializes in high-availability and high-performance SQL systems.#160; Recent projects include: system upgrades, SQL Server platform migrations, performance tuning, custom reporting solutions, and database strategy implementations.#160;#160; Geoff is currently on the leadership team of the Atlanta area Microsoft Database Forum Use
Contact: http://www.bidevelopernetwork.com/blogs/MikeMollenhour
Mike is currently a Business Intelligence Architect for Pragmatic Works in Jacksonville Florida. During the past 3 years he has worked with many clients in multiple sectors to help them with High Availability, data warehousing, Integration Services, Analysis Services, Reporting Services ,SQL Server data mining, and performance tuning. Mike has spoken at several events including SQLSaturday and several Microsoft launch events
LinkedIn: http://www.linkedin.com/in/thesqlguru
Kevin Boles is a SQL Server expert, working exclusively with the product since v6.5. With over 25 years of database experience and over 45,000 man hours of SQL Server engine experience, he holds many related certifications, is an MCT and was a SQL Server MVP from 2007 to 2012. Kevin has been a very successful independent consultant for over 20 years. His passion is the relational engine, especially designing, building, analyzing and tuning high-performance database applications.
The following is a list of sponsors that helped fund the event.


A section (which can represent a room) can be assigned a "state", for example "The lights are off" or "The lights are on due to movement". State changes, states as a condition or changing a state can be done using flow cards in the flow editor. Please note: states, events, flow actions and flow triggers always function for every section, so they are universally usable for all sections of the respective group.
Use a flow action to be able to use in your flow as "action that needs to be executed". You can execute the flow action in the right column of the flow editor.
Every time you have a flow action executed, the app will check which events are applicable to fire. The flow action itself does nothing: you will need to
create an event to determine what needs to be done for that flow.
Use a flow trigger to be able to specify in your event when a follow-up needs to take place, after a flow card has been executed. You use flow triggers in the left column of the flow editor.
You use an event to put together flow actions and triggers. When an action is executed from a flow card in the right column of the flow editor, an event can be fired. An event can change a state, but also execute a flow trigger. If a flow trigger is executed by an event, the flows will be triggered which contain a flow card in the left column for the respective trigger.
Image you have a motion sensor which you want to use to automatically switch on your lights. Make the following flows:
Normally you would obviously do this without State Control, and with only a single flow. This is just an example to show you the settings needed.
You will need the following settings in State Control:
For a full example to use for lighting see the wiki.
To be able to use events within a group, you need to apply the checkbox "Enable events in flow cards" in the group settings.
For groups with states without any further logic, you can better remove the checkbo (you can then no longer edit events for that group, and cannot use
trigger- and action- flow cards).
For further documentation and examples, visit the wiki of the State Control app.


Here I will describe my first experience with Salvia as it occurred on the Big Island under the guidance of my mentor.
Date: Aug-2004
Mindset & Setting:
After a hike which lasted about 30 min up to a beautiful valley on big island, the trip back down revealed a small path into what my mentor simply called the bamboo forest. The hike was refreshing, my mind was clear, and the newness of the bamboo forest (I had never been in one before) was extremely pleasant. My mentor and I sat down on a log after walking about 30 feet into the bamboo forest. A natural resting place where the bamboo seemed to open for us to sit.
Preparations:
My mentor and guide handed me his small metal pipe and we filled it with approx 2 pinches of 5x extract impregnated leaves. Due to the size of the pipe being very small, I was un-certain I would be able to get the pipe hot enough, thus I used a little more then what was recommended because I was sure some would be wasted. To help with this problem I ‘pre-heated’ the pipe without touching the flame to the inside of the bowl.
Timing:
I took 3 full hits within a 3 min period. I held each hit for approx 30 seconds and took the needed ‘breathers’ between hits. At the end of the 2nd I began to experience the initial effects and at the end of the 3rd I needed to hand the pipe to my guide.
Added Notes:
I am a chi gung practitioner and was prepared for alterations in consciousness brought on by ‘serious’ psychedelics. Although the set and setting was actually perfect in my opinion, I also feel my awareness of breath helped ground my mind which allowed me a reference point for the Salvia experience.
Experience:
At the 2nd hit I began to experience the initial effects of the salvia which consisted of a noticeable “shifting” or “slipping” of perspective reality. I can best describe this initial perspective change as becoming cross-eyed for a moment, but then thinking your eyes are straight, but things still appear “crooked”. This slipping or shifting seemed to be amplified by the vertical nature of the bamboo. Before I could reflect on this for to long my mentor recognized this as “the window” and told me to go ahead and take another hit.
At the end of the 3rd hit this “window” I was experiencing as a slipping or shifting of reality seemed to fully open. As a matter of fact as I exhaled out the 3rd.I felt my next inhalation travel directly thru my chest, and this window seemed to fully open into a bubble of awareness that was expanding w/ each breath. This expanding bubble of awareness was extremely mythological in nature, and the perceptions coming in thru my senses took on extremely magical qualities. The texture of the bamboo the verticalness of it’s nature, it’s bending… my eyes followed trials between the stalks… and the ‘slipping’ of earlier seemed a full blown dimensional shift.
Up until this point we were both silent. I said at this point – “this is where the little people live”… and my guide chuckled and winked. (like a good guide should do!)
This is when I heard them. The wind started blowing thru the tops of the bamboo, and my attention shifted to the tops of the bamboo. The bushels of leafy bamboo heads. Talking to each other… in the wind. My body bent and flowed with the stalks waving in the wind, for I was listening in only because I had gone thru some type of identification process. (shape shifted?) w/ the bamboo.
The wind whipped words from bushy stalks leaning to and fro in the sun they were delightfully worshipping. Thus it seemed I was listening in on the conversations of the bamboo, whispering bamboo things in the wind. The most striking thing about this experience was the naturalness of their language.  The “Symbolism” of nature became much more then symbols or signs or abstractions. It became a very old language that I had forgotten how to speak. This experience lasted about 5-8 min.
After about 10 min (3 min after coming back to a reasonable state of mind) I took another 3 hits and looked up thru the bamboo into the warmth of the sun. My head again turned into the bushy stalks but this time I stretched to the tops of the bamboo and reached towards the light and warmth and heat of the sun. It is at this point that I will say I experienced some essence of the “God” of the plants. I also became aware of a larger tree behind me that seemed to have a consciousness bubble of sorts.
I talked at length about this experience w/ my mentor. He noted that the “God” I experienced in the light and energy of the sun is the religion of the plants. Thus it seemed God like because I was identified w/ the plants, I experienced the religion of the plants.
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.


I am a frontend engineer at Infosys, with 15+ years of experience and strong design background, who strongly advocate user experience and human-centred-design (HCD).
I started my career in 2004, on a small company in my hometown and along the years I've been improving my development skills, always focusing my efforts on design, agile methodologies, working with the best performance possible and always encouraging team members to give their best.
I seek to work alongside members of a team in which everyone has something to bring to the table, where open communication is encouraged and creativity is valued, helping them to navigate through complexity and find creative solutions to the user problems.
As an entrepreneur, I have a particular interest in collaborating with startups and small businesses which means of software development and technical advice and help them take their products from the ideation to the achievement stage.