Contacts SH v1.0.0 ContactsSh.Otp.GarbageCollector View Source
Deletes contacts marked for deletion every 10 minutes.
Link to this section Summary
Functions
Returns a specification to start this module under a supervisor
Sends one message to itself every 10 minutes to program the next deletion and another message to delete all marked contacts
Link to this section Functions
Returns a specification to start this module under a supervisor.
See Supervisor
.
Sends one message to itself every 10 minutes to program the next deletion and another message to delete all marked contacts:
Process.send_after(self(), :clean_every_interval, @delete_interval_ms)
send(self(), :delete_contacts)


Unit Testing Stored Procedures
And a pragmatic guide on how to include them into your build system.
10 October 2013 | 27 April 2018
unit testing sqlThis article is based on the notes I’ve collected on My Wiki.
Test Driven Development (or TDD), it’s one of those buzz words which usuallly appear in the same sentence with “scrum” or “XP”. But in practice, I’ve seen few people actually applying it all the way through. What do I mean by that? You’re probably very familiar with, say Java or .NET, and you know how to write unit tests in that language using your beloved IDE. That’s a good start, right. Maybe you might even do it the test-first way: writing a failing test (letting it fail for the right reason), writing the implementation and maybe some refactoring. Red, Green, Refactor.
But what do you do when you need to step out of your language comfort zone to write some Javascript on the client side? Do you copypaste stuff or try to apply the same techniques as you’re used to? You might have heard from test frameworks like Jasmine and use these. Also good for you! Client side development is very popular, but what about SQL? Do you write tests for stored procedures? I thought so. There are plenty of frameworks available to help you in doing this, for instance SQL Developer which I used because it’s already installed on every developer’s PC and has a “friendly” interface.
Once you create a “test repository”, SQL Developer will create test tables to store it’s unit test descriptions and results, prefixed by “UT_“. You can specify whether you’d like to create a new scheme for it or not. When creating a new test, the tool asks you a couple of questions:
- What do you want to insert or execute before the test? (Setup phase)
- What stored procedure do you want to execute? (Execute system under test phase)
- What should the result of the procedure be, or execute a query and check it’s results? (Verify phase)
- What do you want to insert or execute after the test? (Teardown phase)
You can reuse the parts to be executed in the different phases for another unit test, yay! This data will also be stored in the predefined tables.
But what about existing data when inserting new stuff?
use this as teardown:
ROLLBACK;
But how do you execute a stored procedure with IN/OUT REF CURSOR arguments?
SQL Developer has some trouble executing that, indeed. In this case, we use a little trick:
Create a dummy stored procedure:
create or replace PROCEDURE UT_DUMMY AS BEGIN NULL; END UT_DUMMY;
Execute the dummy procedure in the SUT phase.
Use the verify phase to call the actual to test procedure yourself, and do your verification stuff yourself:
DECLARE P_USERID NUMBER; MY_P_CURSOR SCHEMA.PACKAGE.Cursor; cursor_element MY_P_CURSOR.SCHEMA.CursorType; found boolean; BEGIN P_USERID := 11; found := false; PACKAGE.MYPROCEDURE( P_USERID => P_USERID, P_CURSOR => MY_P_CURSOR ); WHILE TRUE LOOP FETCH MY_P_CURSOR INTO cursor_element; EXIT WHEN MY_P_CURSOR%NOTFOUND; IF cursor_element.columntocheck = 'My value' THEN found := true; END IF; END LOOP; IF found = false THEN raise_application_error(-20000, 'Your error message in here!'); END IF; END;
Okay but what about integrating the exeuction of these tests in my build system?
You can use the commandline utility provided by SQL Developer to execute a test or a suite:
ututil -run -suite -name [name] -repo [repo] -db [db] -log 3
It’s very interesting to dynamically import and export tests using “-imp” and “-exp”, and creating one suite using this PL/SQL:
SET serveroutput ON;
delete from ut_suite_items;
delete from ut_suite;
DROP SEQUENCE ut_suite_items_seq;
CREATE SEQUENCE ut_suite_items_seq
MINVALUE 0
MAXVALUE<PHONE_NUMBER>99999999999999999
START WITH 0
INCREMENT BY 1;
DECLARE
suiteid VARCHAR2(900) := 'ALL';
utid VARCHAR2(900);
cursor tableCursor is SELECT UT_ID FROM UT_TEST;
BEGIN
dbms_output.enable(10000);
DBMS_OUTPUT.PUT_LINE('Creating one test suite to rule them ALL...');
insert into ut_suite(ut_sid, coverage, name, created_on, created_by, updated_on, updated_by)
values(suiteid, 0, suiteid, null, null, null, null);
open tableCursor;
fetch tableCursor into utid;
WHILE (tableCursor%FOUND) LOOP
insert into ut_suite_items(ut_sid, ut_id, ut_nsid, run_start, run_tear, sequence, created_on, created_by, updated_on, updated_by)
values (suiteid, utid, null, 'Y', 'Y', ut_suite_items_seq.nextval, null, null, null, null);
fetch tableCursor into utid;
END LOOP;
close tableCursor;
commit;
DBMS_OUTPUT.PUT_LINE('SUCCESS - test suite created!');
END;
/
It creates only one suite called ‘ALL’ which can then be executed. The commandline utility will output “UT_SUCCESS” or throw some kind of exception if one of the tests failed.
I still get errors using ututil, some ConnectException?
the utility cannot handle any TNS connections you’ve entered in SQL Developer. Change these to regular connection strings and all will be well. Yes it’s a huge disadvantage, and yes the connection settings are stored in your locally installed SQL Developer instance, which also kind of sucks. We needed to install SQL developer on the Build integration PC and configure the same connections within it.
What about versioning? The tests are stored in my DB, but it doesn’t evolve as quickly as the code does!
Right, that’s where the import/export thing comes in. We store the actual unit tests in XML format inside our regular source control system, next to the “other” unit tests (in this case in .NET). Every time someone writes a unit test using SQL developer, it extracts that test using:
ututil -exp -test [name] -file [file] ...
which creates an XML file. Executing the tests happen within a wrapper .NET test class, which goes through some steps to setup the DB system correctly:
- Cleanup all UT_TEST* and UT_SUITE* tables which would contain the acutal tests.
- Loop through all XML files, and impor them one by one (they get inserted into the cleaned tables)
- Generate the ‘ALL’ unit test suite - see PL/SQL above.
- Execute the test suite using ututil and parse the results from the command line.
That’s as far as our imagination and budget goes. We have a stable system which is able to version the XML files - inserting the test data is still dependant on the actual state of the database. One could explore the dynamic creating of tables the stored procedures use, but as our codebase is legacy (read: really really old stuff), we decided not to invest too much time in that.


Speech Transformer¶
Speech Transformer¶
-
class
kospeech.models.transformer.model.
SpeechTransformer
(num_classes: int, d_model: int = 512, input_dim: int = 80, pad_id: int = 0, eos_id: int = 2, d_ff: int = 2048, num_heads: int = 8, num_encoder_layers: int = 6, num_decoder_layers: int = 6, dropout_p: float = 0.3, ffnet_style: str = 'ff', extractor: str = 'vgg')[source]¶ A Speech Transformer model. User is able to modify the attributes as needed. The architecture is based on the paper “Attention Is All You Need”.
Parameters: - num_classes (int) – the number of classfication
- d_model (int) – dimension of model (default: 512)
- input_dim (int) – dimension of input
- pad_id (int) – identification of <PAD_token>
- eos_id (int) – identification of <EOS_token>
- d_ff (int) – dimension of feed forward network (default: 2048)
- num_encoder_layers (int) – number of encoder layers (default: 6)
- num_decoder_layers (int) – number of decoder layers (default: 6)
- num_heads (int) – number of attention heads (default: 8)
- dropout_p (float) – dropout probability (default: 0.3)
- ffnet_style (str) – if poswise_ffnet is ‘ff’, position-wise feed forware network to be a feed forward, otherwise, position-wise feed forward network to be a convolution layer. (default: ff)
- Inputs: inputs, targets
- inputs (batch, input_length): tensor containing input sequences
- targets (batch, target_length): tensor contatining target sequences
- Returns: output
- output: tensor containing the outputs
-
forward
(inputs: torch.Tensor, input_lengths: torch.Tensor, targets: Optional[torch.Tensor] = None, return_attns: bool = False)[source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
-
class
kospeech.models.transformer.model.
SpeechTransformerDecoder
(num_classes: int, d_model: int = 512, d_ff: int = 512, num_layers: int = 6, num_heads: int = 8, ffnet_style: str = 'ff', dropout_p: float = 0.3, pad_id: int = 0, eos_id: int = 2)[source]¶ The TransformerDecoder is composed of a stack of N identical layers. Each layer has three sub-layers. The first is a multi-head self-attention mechanism, and the second is a multi-head attention mechanism, third is a feed-forward network.
Parameters: - num_classes – umber of classes
- d_model – dimension of model
- d_ff – dimension of feed forward network
- num_layers – number of decoder layers
- num_heads – number of attention heads
- ffnet_style – style of feed forward network
- dropout_p – probability of dropout
- pad_id – identification of pad token
- eos_id – identification of end of sentence token
-
forward
(inputs: torch.Tensor, input_lengths: Optional[Any] = None, memory: torch.Tensor = None)[source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
-
class
kospeech.models.transformer.model.
SpeechTransformerEncoder
(d_model: int = 512, input_dim: int = 80, d_ff: int = 2048, num_layers: int = 6, num_heads: int = 8, ffnet_style: str = 'ff', dropout_p: float = 0.3, pad_id: int = 0)[source]¶ The TransformerEncoder is composed of a stack of N identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, position-wise fully connected feed-forward network.
Parameters: - d_model – dimension of model (default: 512)
- input_dim – dimension of feature vector (default: 80)
- d_ff – dimension of feed forward network (default: 2048)
- num_layers – number of encoder layers (default: 6)
- num_heads – number of attention heads (default: 8)
- ffnet_style – style of feed forward network [ff, conv] (default: ff)
- dropout_p – probability of dropout (default: 0.3)
- pad_id – identification of pad token (default: 0)
Layers¶
-
class
kospeech.models.transformer.layers.
SpeechTransformerDecoderLayer
(d_model: int = 512, num_heads: int = 8, d_ff: int = 2048, dropout_p: float = 0.3, ffnet_style: str = 'ff')[source]¶ DecoderLayer is made up of self-attention, multi-head attention and feedforward network. This standard decoder layer is based on the paper “Attention Is All You Need”.
Parameters: - d_model – dimension of model (default: 512)
- num_heads – number of attention heads (default: 8)
- d_ff – dimension of feed forward network (default: 2048)
- dropout_p – probability of dropout (default: 0.3)
- ffnet_style – style of feed forward network [ff, conv] (default: ff)
-
forward
(inputs: torch.Tensor, memory: torch.Tensor, non_pad_mask: Optional[Any] = None, self_attn_mask: Optional[Any] = None, memory_mask: Optional[Any] = None) → Tuple[torch.Tensor, torch.Tensor, torch.Tensor][source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
-
class
kospeech.models.transformer.layers.
SpeechTransformerEncoderLayer
(d_model: int = 512, num_heads: int = 8, d_ff: int = 2048, dropout_p: float = 0.3, ffnet_style: str = 'ff')[source]¶ EncoderLayer is made up of self-attention and feedforward network. This standard encoder layer is based on the paper “Attention Is All You Need”.
Parameters: - d_model – dimension of model (default: 512)
- num_heads – number of attention heads (default: 8)
- d_ff – dimension of feed forward network (default: 2048)
- dropout_p – probability of dropout (default: 0.3)
- ffnet_style – style of feed forward network [ff, conv] (default: ff)
-
forward
(inputs: torch.Tensor, non_pad_mask: Optional[Any] = None, self_attn_mask: Optional[Any] = None) → Tuple[torch.Tensor, torch.Tensor][source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
Sublayers¶
-
class
kospeech.models.transformer.sublayers.
AddNorm
(sublayer: torch.nn.modules.module.Module, d_model: int = 512)[source]¶ Add & Normalization layer proposed in “Attention Is All You Need”. Transformer employ a residual connection around each of the two sub-layers, (Multi-Head Attention & Feed-Forward) followed by layer normalization.
-
forward
(*args)[source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
-
-
class
kospeech.models.transformer.sublayers.
PositionWiseFeedForwardNet
(d_model: int = 512, d_ff: int = 2048, dropout_p: float = 0.3, ffnet_style: str = 'ff')[source]¶ Position-wise Feedforward Networks proposed in “Attention Is All You Need”. Fully connected feed-forward network, which is applied to each position separately and identically. This consists of two linear transformations with a ReLU activation in between. Another way of describing this is as two convolutions with kernel size 1.
-
forward
(inputs: torch.Tensor) → torch.Tensor[source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
-
Embeddings¶
-
class
kospeech.models.transformer.embeddings.
Embedding
(num_embeddings: int, pad_id: int, d_model: int = 512)[source]¶ Embedding layer. Similarly to other sequence transduction models, transformer use learned embeddings to convert the input tokens and output tokens to vectors of dimension d_model. In the embedding layers, transformer multiply those weights by sqrt(d_model)
-
forward
(inputs: torch.Tensor) → torch.Tensor[source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
-
-
class
kospeech.models.transformer.embeddings.
PositionalEncoding
(d_model: int = 512, max_len: int = 5000)[source]¶ Positional Encoding proposed in “Attention Is All You Need”. Since transformer contains no recurrence and no convolution, in order for the model to make use of the order of the sequence, we must add some positional information.
- “Attention Is All You Need” use sine and cosine functions of different frequencies:
- PE_(pos, 2i) = sin(pos / power(10000, 2i / d_model)) PE_(pos, 2i+1) = cos(pos / power(10000, 2i / d_model))
-
forward
(length: int) → torch.Tensor[source]¶ Defines the computation performed at every call.
Should be overridden by all subclasses.
Note
Although the recipe for forward pass needs to be defined within this function, one should call the
Module
instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.
Mask¶
-
kospeech.models.transformer.mask.
get_attn_pad_mask
(inputs, input_lengths, expand_length)[source]¶ mask position is set to 1
- Examples::
>>> get_attn_pad_mask(inputs, input_lengths, expand_length) tensor([[[False, False, False, False, False, True, True, True, True], [False, False, False, False, False, True, True, True, True], [False, False, False, False, False, True, True, True, True]],
- [[False, False, False, False, False, False, True, True, True],
- [False, False, False, False, False, False, True, True, True], [False, False, False, False, False, False, True, True, True]],
- [[False, False, False, False, False, False, False, False, True],
- [False, False, False, False, False, False, False, False, True], [False, False, False, False, False, False, False, False, True]]])
-
kospeech.models.transformer.mask.
get_decoder_self_attn_mask
(seq_k: torch.Tensor, seq_q: torch.Tensor, pad_id)[source]¶ For masking the decoder self attention
- Example::
>>> get_decoder_self_attn_mask(seq_k, seq_q, pad_id) tensor([[[False, True, True, True, True, True, True], [False, False, True, True, True, True, True], [False, False, False, True, True, True, True], [False, False, False, False, True, True, True], [False, False, False, False, True, True, True], [False, False, False, False, True, True, True], [False, False, False, False, True, True, True]],
- [[False, True, True, True, True, True, True],
- [False, False, True, True, True, True, True], [False, False, False, True, True, True, True], [False, False, False, False, True, True, True], [False, False, False, False, False, True, True], [False, False, False, False, False, True, True], [False, False, False, False, False, True, True]],
- [[False, True, True, True, True, True, True],
- [False, False, True, True, True, True, True], [False, False, False, True, True, True, True], [False, False, False, False, True, True, True], [False, False, False, False, False, True, True], [False, False, False, False, False, False, True], [False, False, False, False, False, False, True]]])
-
kospeech.models.transformer.mask.
get_pad_mask
(inputs: torch.Tensor, input_lengths: Optional[Any] = None, pad_id: int = None) → torch.Tensor[source]¶ Padding position is set to True, either use input_lengths or pad_id
- Examples::
>>> get_pad_mask(inputs, input_lengths) tensor([[[False], [False], [False], [False], [False], [ True], [ True], [ True], [ True]], [[False], [False], [False], [False], [False], [False], [ True], [ True], [ True]], [[False], [False], [False], [False], [False], [False], [False], [False], [ True]]])


Virtual Qmail
Developers
Documentation
SourceForge
Download files
Site map
start
::
SourceForge
Forums
Tracker
Mailing lists
Project site
is hosted by SourceForge.
Copyrigth 2003, created by Pawel Niewiadomski


EXIFGREP(1) EXIFGREP(1)
NAME
exifgrep - select and reformat the output of exifprobe
SYNOPSIS
exifgrep [options] [egrep_options] egrep_pattern [NOT egrep-pattern]
filename(s)
DESCRIPTION
Exifgrep is a shell script which applies egrep(1) to the output of
exifprobe -L, permitting easy selection and minor reformatting of out-
put items.
exifprobe is small, fast, and utterly sycophantic in its desire to
report everything it finds in an image. exifgrep applies the regular
expression matching capabilities of egrep to the output barrage to
extract only wanted information.
exifgrep also performs a mild form of selection on the output fields of
exifprobe -L. Many items reported by exifprobe are represented in the
image file by a number which compactly represents a defined value.
E.g. exifprobe -L may report
TIFF.Ifd1.ResolutionUnit = 2 = 'pixels per inch'
where the value "2" must be interpreted to mean that resolution values
(TIFF.IFd1.Xresolution and IFF.IFd1.YResolution) are recorded in pixels
per inch, rather than, say, pixels per centimeter. exifprobe reports
both fields; exifprobe may also report interpreted values for items
which are recorded in unfamiliar units, such as
JPEG.APP1.Ifd0.Exif.FNumber = 5.6 APEX = 'f7.0'
In all such cases, exifgrep reports (by default) only the "human read-
able" field:
TIFF.Ifd1.ResolutionUnit = 'pixels per inch'
JPEG.APP1.Ifd0.Exif.FNumber = 'f7.0'
unless the "-num" option is given to select the numerical value.
In addition, a `variable' format may be selected ("-var") which elimi-
nates whitespace, providing a format which typical shells may use
directly to set variables for further processing. E.g.
TIFF.Ifd1.ResolutionUnit='pixels per inch'
JPEG.APP1.Ifd0.Exif.FNumber='f7.0'
OPTIONS
-r file arguments may be directories, which will be searched via
find for all image types recognized by exifprobe.
-n force exifprobe to print a filename for each line of its out-
put, which exifgrep will turn into a comment at the end of
each matching line.
-t force exifprobe to print tag numbers for all itemes that have
them, so that matches may be made on hex or decimal tag
numbers.
-c turn on color output from exifprobe
-h print a usage message (help)
-var report in "variable" format, which may be directly `sourced'
by any Bourne-compatible shell (except that most shells will
insist that the dots must be replaced, e.g. by underscores).
-export report in "variable" format, but with a Bourne-compatible
export command
-num report numerical values rather than interpreted strings, for
fields which have both.
NOTE: the -var and -export options are obsolescent; they are retained
for compatibility with earlier versions of exifprobe. A post-processor
such as reformat.sh may be more effective for the current version if
shell-compatible output is desired.
Any option not recognized by the script will be passed on to egrep.
The first non-option argument will be used as the pattern passed to
egrep. This may be followed by the keyword NOT and an expression rep-
resenting matches to be rejected. This pattern will be passed to egrep
-v. Only one argument of each type may be given, and the "accept"
expression (if given) must appear before the "reject" expression.
All remaining arguments are interpreted as image filenames.
SEE ALSO
exifprobe(1)
AUTHOR
Duane H. Hesser
<EMAIL_ADDRESS>LOCAL EXIFGREP(1)
Man(1) output converted with
man2html


×
Account
My Profile
Communities
Excluzeev Live
Setting
COMPANY
About
Careers
News
SUPPORT
Contact Support
Help Guide
FAQ
LEAGAL
Logout
Career with Excluzeev
Descrtiption about careers with excluzeev
Please Enter Your Details
First Name
*
Last Name
*
Email
*
Message
Cancel
Send


Welcome to my world, a place where I let my mind wander where it will
On these pages I share those wanderings, thoughts that have appeared randomly, with no structure or deep meaning. Just the ramblings of an old man that has seen many things around the world. Enjoy, or not, that is your choice.
Most people have heard of the Serenity Prayer, "God, grant me the serenity to accept the things I cannot change, the courage to change the things I can, and the wisdom to know the difference." I have a variation I try to use in my daily life, "O Lord, grant me the serenity to accept the people I cannot change, the courage to change the “one” I can, and the wisdom to know that "that one" is ME!"
From Mr. Inbetween, a very interesting TV show from Australia: “You know why the world is full of A-holes? Because they get away with it. If you take away personal responsibility you get anarchy. Actions should have consequences that fit the action". For more information about the show
Nietzsche’s complaint against philosophers: They all pose as though their real opinions had been discovered and attained through logic whereas, in fact, a prejudiced proposition, idea, or “suggestion,” which is generally their heart’s desire abstracted and refined, is defended by them with arguments sought out after the event.


ALTER OPERATOR
Section: SQL Commands (7)Updated: 2012-08-14
Index Return to Main Contents
NAME
ALTER OPERATOR - change the definition of an operatorSYNOPSIS
ALTER OPERATOR name ( { lefttype | NONE } , { righttype | NONE } ) OWNER TO newowner
DESCRIPTION
ALTER OPERATOR changes the definition of an operator. The only currently available functionality is to change the owner of the operator.
You must own the operator to use ALTER OPERATOR. To alter the owner, you must also be a direct or indirect member of the new owning role, and that role must have CREATE privilege on the operator's schema. (These restrictions enforce that altering the owner doesn't do anything you couldn't do by dropping and recreating the operator. However, a superuser can alter ownership of any operator anyway.)
PARAMETERS
- name
- The name (optionally schema-qualified) of an existing operator.
- lefttype
- The data type of the operator's left operand; write NONE if the operator has no left operand.
- righttype
- The data type of the operator's right operand; write NONE if the operator has no right operand.
- newowner
- The new owner of the operator.
EXAMPLES
Change the owner of a custom operator a @@ b for type text:
ALTER OPERATOR @@ (text, text) OWNER TO joe;
COMPATIBILITY
There is no ALTER OPERATOR statement in the SQL standard.
SEE ALSO
CREATE OPERATOR [create_operator(7)], DROP OPERATOR [drop_operator(7)]
Index
This document was created by man2html, using the manual pages.
Time: 05:34:14 GMT, December 24, 2015


--- layout: page title: C++ Documentation permalink: /cpp/ ---
Logitech Gaming Software must be running with the "Allow games to control illumination" setting enabled for Logitech devices to be controlled. Corsair Utility Engine (CUE) must be running for Corsair devices to be controlled.
Namespace: Spectral
Performs operations for RGB LED Illumination.
{% highlight cpp %} class Led {% endhighlight %}| CorsairIsEnabled() | Checks if Corsair device support was enabled during initialization. |
| Initialize() | Manually initialize the Spectral library. If Spectral is not initialized, this method will be called when trying to perform operations. |
| IsInitialized() | Checks if the Spectral library is initialized. |
| LogitechIsEnabled() | Checks if Logitech device support was enabled during initialization. |
| SetColor(unsigned char, unsigned char, unsigned char) | Sets the color of all LEDs on enabled devices to the specified color. |
| SetColorForDevice(DeviceType, unsigned char, unsigned char, unsigned char) | Sets the color of all enabled devices of the specified type to the specified color. |
| SetColorForLed(LedName, unsigned char, unsigned char, unsigned char) | Sets the color of the specified LED on enabled devices to the specified color. |
| SetColorForLeds(vector<LedName>, unsigned char, unsigned char, unsigned char) | Sets the color of the specified LEDs on enabled devices to the specified color. |
| Shutdown() | Manually shut down the Spectral library. If not called, the library should shutdown when the application exits. |
Checks if Corsair device support was enabled during initialization.
{% highlight cpp %} static bool CorsairIsEnabled(); {% endhighlight %}bool
True if Corsair device support is enabled.
Manually initialize the Spectral library. If Spectral is not initialized, this method will be called when trying to perform operations.
{% highlight cpp %} static bool Initialize(); {% endhighlight %}bool
True if initialization was successful.
Checks if Logitech device support was enabled during initialization.
{% highlight cpp %} static bool LogitechIsEnabled(); {% endhighlight %}bool
True if Logitech device support is enabled.
Sets the color of all LEDs on enabled devices to the specified color.
{% highlight cpp %} static bool SetColor(unsigned char red, unsigned char green, unsigned char blue); {% endhighlight %}red
unsigned char
The red channel value for the color to set. On monochromatic devices, only the highest channel value is used.
green
unsigned char
The green channel value for the color to set. On monochromatic devices, only the highest channel value is used.
blue
unsigned char
The blue channel value for the color to set. On monochromatic devices, only the highest channel value is used.
bool
True if LEDs on all enabled devices were successfully set.
Sets the color of all enabled devices of the specified type to the specified color.
{% highlight cpp %} static bool SetColorForDevice(DeviceType deviceType, unsigned char red, unsigned char green, unsigned char blue); {% endhighlight %}deviceType
DeviceType
The type of devices to set.
red
unsigned char
The red channel value for the color to set. On monochromatic devices, only the highest channel value is used.
green
unsigned char
The green channel value for the color to set. On monochromatic devices, only the highest channel value is used.
blue
unsigned char
The blue channel value for the color to set. On monochromatic devices, only the highest channel value is used.
bool
True if LEDs on all enabled devices were successfully set.
Sets the color of the specified LED on enabled devices to the specified color.
{% highlight cpp %} static bool SetColorForLed(LedName ledName, unsigned char red, unsigned char green, unsigned char blue); {% endhighlight %}ledName
LedName
The LED Name value for the LED to be set.
red
unsigned char
The red channel value for the color to set. On monochromatic devices, only the highest channel value is used.
green
unsigned char
The green channel value for the color to set. On monochromatic devices, only the highest channel value is used.
blue
unsigned char
The blue channel value for the color to set. On monochromatic devices, only the highest channel value is used.
bool
True if specified LED on any enabled device was successfully set.
Sets the color of the specified LEDs on enabled devices to the specified color.
{% highlight cpp %} static bool SetColorForLeds(std::vectorledNames
LedName
The LED Name values for the LEDs to be set.
red
unsigned char
The red channel value for the color to set. On monochromatic devices, only the highest channel value is used.
green
unsigned char
The green channel value for the color to set. On monochromatic devices, only the highest channel value is used.
blue
unsigned char
The blue channel value for the color to set. On monochromatic devices, only the highest channel value is used.
bool
True if specified LEDs on any enabled device was successfully set.
Manually shut down the Spectral library. If not called, the library should shutdown when the application exits.
{% highlight cpp %} static void Shutdown(); {% endhighlight %}


In user interface design, a modal window is a child window that requires users to interact with it before they can return to operating the parent application, thus preventing the workflow on the application main window. Modal windows are often called heavy windows or modal dialogs because the window is often used to display a dialog box.
Modal windows are commonly used in GUI systems to command user awareness and to display emergency states, although they have been argued to be ineffective for that use. Modal windows are prone to produce mode errors. On the Web, they are often used to show images in detail, in a pattern known as a Lightbox.
Size at open:
Time to open:
A modal window blocks all other workflow in the top-level program until the modal window is closed, as opposed to modeless dialogs that allow users to operate with other windows. Modal windows are intended to grab the user's full attention. Users may not recognize that a modal window requires their attention, leading to confusion about the main window being non-responsive, or causing loss of the user's data input intended for the main window (see Mode error). In some more pathological cases, the modal window will appear behind another window controlled by the same program, potentially rendering the entire program unresponsive until the modal window can be located manually.
However, many interface designers have recently taken steps to make modal windows more obvious and user friendly by darkening the background behind the window or allowing any mouse click outside of the modal window to force the window to close – a design called a Lightbox – thus alleviating those problems. Jakob Nielsen states as an advantage of modal dialogs that it improves user awareness: "When something does need fixing, it's better to make sure that the user knows about it". For this goal, the lightbox design provides strong visual contrast of the dialog over the rest of the visuals. The lightbox technique is now a common tool in website design.


In this post I will show you how to use Spring aspects. In contrast to AspectJ aspects that are implemented by either compile time or load time bytecode manipulation (process often called waving), Spring aspects are implemented using proxy classes. The main advantage of proxy aspect implementation is ease of use, the main disadvantage is reduced functionality of aspects (e.g. we cannot intercept calls to static methods).
Diagram below illustrates how proxy classes are used to
add functionality contained in Aspect I
and Aspect II
to
MyComponentImpl
class:
When application asks Spring for MyComponent
implementation Spring detects that there are aspects attached to
MyComponentImpl
class,
so instead of returning MyComponentImpl
instance
Spring creates and returns a proxy.
Proxy returned to client implements MyComponent
interface
and by default redirects all method calls to MyComponentImpl
instance.
In some situations like e.g. calling a doStuff()
method
proxy may execute code (called advice) from Aspect I
and/or Aspect II
,
thus adding functionality to MyComponentImpl
class.
Application setup
Before we create our first aspect we need to setup our application.
Let’s start with Maven dependencies. We will need spring-aspects
and aspectjweaver
libraries.
You may be wondering why we need something from AspectJ which we
don’t use. Spring Framework supports not only proxy based aspects
but also full blown AspectJ aspects, to avoid code duplication
designers of Spring decided to borrow annotation definitions like @Aspect
from AspectJ project.
Thus aspectjweaver
is only used as an annotation library and nothing more.
Next we need to create Spring configuration class and bootstrap Spring context:
NOTE: To enable proxy based aspects we need to add @EnableAspectJAutoProxy
annotation to our configuration class.
Creating aspects
Before we start let’s introduce some terminology. Advice is
a piece of code that should be executed when certain event
like calling a method takes place. A pointcut is a set of
events, for example all calls to a method foo()
contained in
class Bar
. A join point is a single event for example a
particular invocation of method foo()
on line 105 in class Bar
.
Aspect is a pointcut-advice pair, in other words aspect defines
what should be done (advice) and when (pointcut).
Spring borrowed this terminology from AspectJ, it takes a while
to get used to it.
We will start by crating @Before
and @After
aspects that
as their names suggest are invoked before and after a method call.
Our aspects will add functionality to the following component:
Let’s start with @Before
aspect
(here I use the same name for aspect and advice, but remember that they
are two different things):
A few things to notice:
DummyAspect
class will contain definitions of our aspects, we may define many aspects inside a single classDummyAspect
must be registered as a Spring component (here I used@Component
annotation). This also means that dependency injection works inside aspects- Class must be marked with
@Aspect
annotation otherwise Spring will ignore our aspects - Optionally we may provide
@Order
annotation that specifies order of aspects (e.g. when there is more than one aspect attached to a given method call). The higher the order value the more close the aspect is to the original method call, see the diagram below:
Now let’s see how @Before
aspects works.
A pointcut defines a set of events (like calling a method) to which we want to
attach advices.
For example to create a pointcut that will “point” to every invocation of
DummyComponent::doStuff
method, we may write:
This code creates named pointcut with doStuff
name.
Strange expressions passed to @Pointcut
annotation is
borrowed from AspectJ, it tells Spring that we want to
select method calls execution
, of methods that may return any
type *
, and are members of io.mc.springaspects.DummyComponent
class,
and are named doStuff
, and doesn’t take any parameters ()
.
Now let’s move to the advice:
Advice is implemented as an instance method, first we
declare that this is a @Before
advice - so it will be called
before target method. We also define where we want to use
advice by passing pointcut name to @Before
annotation.
Advice method may optionally have a JoinPoint
argument that
represents particular invocation of doStuff()
method.
JoinPoint
contains many useful informations
like doStuff()
method arguments, or value of this
reference.
Let’s check if our aspect works:
Yay! It is but since doStuff
doesn’t have any parameters we
can’t test arguments logging. We will fix that now, by adding
a single parameter of type String
to doStuff
method:
Since we changed method signature we must also change our pointcut definition:
We are using ..
to tell Spring that method may have any number of arguments.
We may also specify exact number and types of arguments for example:
With changed pointcut we now get:
Extracting arguments
Sometimes we want to extract method argument value, instead
of manually extracting argument from JoinPoint
we may ask Spring
to do this for us.
Let’s add another parameter to doStuff
:
Then let’s define another aspect:
Here we use args
expression to bound method arguments to arg1
and arg2
variables. Then we may use arg1
and arg2
as a parameters in aspect method.
Don’t forget to add parameters to pointcut name in @Before
annotation otherwise
you will get nasty exception with strange and unhelpful message.
Modifying method parameters
Aspects allow us to easily change values of method arguments. For example given method:
We may create aspect toUpperCase
that will uppercase user name
before passing argument to target method.
Unfortunately @Before
aspect is not powerful enough to do this,
we will need @Around
aspect:
@Around
advice has a single parameter of type ProceedingJoinPoint
that
represents pending target method invocation. This is very powerful feature since
it allows us to change method parameters and return value, wrap
thrown exceptions or even skip method call altogether.
Here we simply invoke target method with changed arguments using ProceedingJoinPoint::proceed
call.
Modifying return value
Aspects allow us to change return value of a method.
For example let’s add method to our DummyComponent
class:
Notice that for size
equal zero getNumbers
returns null
.
Returning null instead of empty collection
isn’t good programming practice let’s change that
behaviour using aspects.
We will start with already familiar @Around
advice:
If @Around
advice method returns value then that
value will be used as return value
of the target method, this is exactly what we do here.
If we only want to access return value we may also use
@AfterReturning
advice:
Here we cannot change returned value itself but we may call methods on it, set properties etc.
Intercepting exceptions
We may use @Around
advice to intercept, handle or wrap exceptions thrown
by target method (just add ordinary try..catch
statement around
proceed
call). Here we will concentrate on @AfterThrowing
advice
that allows us to inspect exceptions thrown by target method.
In DummyComponent
we must add method:
We must also declare our exception class:
And pointcut-advice pair:
Aspects and interface methods
So far we only attached advices to concrete classes like DummyComponent
,
in real applications we often want to attach advices to all implementations
of given interface.
Fortunately for us Spring supports this scenario.
We will start by declaring DummyInterface
interface
and its two implementations:
Now we may attach our advice to DummyInterface::dummyMethod
:
In pointcut expression I used DummyInterface+
to select
all classes that implement DummyInterface
.
In pointcut expression we are not limited to a single method, we may use
DummyInterface+.*(..)
expression to attach advice to all interface methods.
Let’s check if our advice works:
Aspects and annotations
Another common scenario in real life apps is to attach advices to methods marked with given annotation. Let’s start by creating custom annotation:
Then we must create test method in DummyComponent
and mark it with
@UseAdviceOnThisMethod
annotation:
And finally we must create pointcut-advice pair:
In pointcut expression we use * *.*(..)
to signify that we want
to consider methods with any return type, within any class, with any
name and taking any number and types of arguments.
But we also use @io.mc.springaspects.UseAdviceOnThisMethod
expression
to point only to these methods that are annotated with @UseAdviceOnThisMethod
.
Often in advice we want to access annotation to read some values from it.
To access annotation we may modify our @Before
advice to:
Aspects and proxy unwrapping
Since Spring aspects are implemented using proxy classes we may skip advice invocation by unwrapping Spring bean:
The End
We only scratched the surface of what Spring aspects can do, and we only used basic expressions in pointcut definitions. Aspect oriented programming is a huge topic and requires time and practice to master. I hope that this blog post helped you to understand what apects are and how to use them in Spring. If you have any remarks how I can improve this post please leave a comment.


Placeholder page
This page will contain the enrollment form for housing.
Housing resources available
Lorem ipsum, dolor sit amet consectetur adipisicing elit. Cupiditate pariatur nesciunt voluptas mollitia? Quis, suscipit modi placeat officia nam saepe, provident nulla iusto ratione perspiciatis adipisci quam consectetur laudantium inventore.
Leaflet webmap and OpenStreetMap tiles
Are you willing to share your experience with science?
Many healthcare workers are trying to decide whether to self-quarantine without much evidence-base from which to make their decisions for minimizing exposure risk. By participating voluntarily in a research study of front line health care workers, you will provide data on the impact of self-quarantine, to improve pandemic preparation and to optimize outcomes for patients, clinicians, and the community.
The VoSQua research study is NOT required to participate in the HOSTED cohort or to receive housing and resources. If you are interested in participating in a short baseline survey with the option to provide more data later, click here.


Project: DeathNote
Code contributed: Functional code Test code
DeathNote is a desktop address book application to remember the people you hate. The user interacts with the application mainly using a command line interface, and minimal GUI interface created with JavaFX. The project is written in Java.
Add a person: add
/ a
/ curse
V2.0
Adds a person to DeathNote
Format: add n/NAME [p/PHONE] [e/EMAIL] [a/ADDRESS] [b/BIRTHDAY] [w/WEBSITE] [pic/PATH] [t/TAG]...
Shorthand: a n/NAME [p/PHONE] [e/EMAIL] [a/ADDRESS] [b/BIRTHDAY] [w/WEBSITE] [pic/PATH] [t/TAG]...
Alias: curse n/NAME [p/PHONE] [e/EMAIL] [a/ADDRESS] [b/BIRTHDAY] [w/WEBSITE] [pic/PATH] [t/TAG]...
-
Only
NAME
field is compulsory
End of Extract
Justification
Most of the time we don’t have the full contact information about a person. This feature allows them to use DeathNote just as well.
Making parameters optional
Adding a new person into DeathNote requires only Name
. All other fields are optional. This is
achieved by allowing field objects to be instantiated with null
parameter.
Problems arise when field objects are instantiated with a null
parameter. Necessary changes are mostly about additional
checks of null
in its respective class:
public Phone(String phone) throws IllegalValueException { String trimmedPhone = phone == null ? null : phone.trim(); if (!isValidPhone(trimmedPhone)) { throw new IllegalValueException(MESSAGE_PHONE_CONSTRAINTS); } this.value = trimmedPhone; }
public static boolean isValidPhone(String test) { return test == null || test.matches(PHONE_VALIDATION_REGEX); }
public boolean equals(Object other) { if (other == this) { // short circuit if same object return true; } else if (!(other instanceof Phone)) { // instanceof handle nulls return false; } else if (this.value == ((Phone) other).value) { return true; } else if (this.value != null && this.value.equals(((Phone) other).value)) { // state check return true; } return false; }
Design considerations
Aspect: Which component is responsible for null
.
Alternative 1 (current choice): Parameters can be instantiated with null
parameter, but the object itself cannot be null
.
Pros: Only parameter classes that are within Model
component need to be modified. Other components are still functioning
correctly. This improves coherent within Model
component.
Cons: Potentially confusing for new developers. This design is equivalent to "having a phone with null
number" rather
than the more intuitive "doesn’t have a phone".
Alternative 2: Parameter objects can be null
.
Pros: More intuitive for a new developer. Easier modification on Model
component.
Cons: Many components rely on the assumption that parameter objects are non-null. Hence, this design will fail the other components.
More verification is needed outside the Model
component when interacting with these parameter objects. This increases coupling.
End of Extract
Create new DeathNote : new
/ n
V2.0
Opens a new instance of DeathNote.
Format: new PATH
Shorthand: n PATH
New
On GUI:
-
Go to the top menu and click File > New.
-
Locate your desired DeathNote data file on the pop-up window. The file will be in an xml format.
-
Select the file and click Save
Open existing DeathNote : open
/ o
V2.0
Opens another existing instance of DeathNote.
Format: open PATH
Shorthand: o PATH
Open
On GUI:
-
Go to the top menu and click File > Open.
-
Locate your desired DeathNote data file on the pop-up window. The file will be in an xml format.
-
Select the file and click Open
End of Extract
Justification
This feature allows multiple users to use the same application on the same device but accessing their own version of DeathNote.
open
and new
command mechanism
Figure 4.2.1 : Open Existing Address Book Sequence Diagram
Figure 4.2.2 : Create New Address Book Sequence Diagram
From the sequence diagram, we can see that the workflow is very similar. One thing to note is that even though the
preprocessing is different, in the end they will post the same SwitchAddressBookRequestEvent
to the EventsCenter
.
Design considerations
Aspect: Similarity of implementation for Open and New command.
Alternative 1 (current choice): Separate the two commands until the final post
event.
Pros: Middle ground between Alternative 2 and Alternative 3. Merge similar actions together while separating classes
that are doing different operations. In this case, the similar part is to finally open a new DeathNote (reset, initialize, restart…).
Therefore, we use the same RequestEvent for both commands. The preprocessing is different, since one check for existing file and one
check for the other way round, we separate both of them.
Cons: Slightly harder for developers to get understand how SwitchAddressBookRequestEvent
works.
Alternative 2: Separate the two commands totally.
Pros: Easier for new developers to understand the underlying mechanism because they can treat them as different operations.
Cons: Hard to maintain. Since two commands are very similar. If a bug is found in one of them, the other one is
likely to be affected as well. Hence twice amount of work for the same outcome.
Alternative 3: Combine the two commands totally.
Pros: Easier to maintain because everything is within the same class.
Cons: Confusing to understand. NewCommand checks that Path
is not an existing file but OpenCommand checks that Path
is an existing file. The implementation is likely to have many conditional statements. Changing one class affects both commands.
End of Extract
Find a person: find
/ f
/ summon
V2.0
Finds persons who matches the given attributes.
Format: find [n/NAME] [p/PHONE] [e/EMAIL] [a/ADDRESS] [b/BIRTHDAY] [w/WEBSITE] [t/TAG]...
Shorthand: f [n/NAME] [p/PHONE] [e/EMAIL] [a/ADDRESS] [b/BIRTHDAY] [w/WEBSITE] [t/TAG]...
Alias: summon [n/NAME] [p/PHONE] [e/EMAIL] [a/ADDRESS] [b/BIRTHDAY] [w/WEBSITE] [t/TAG]...
-
The search is case insensitive for
NAME
. If you want to look forHans
, you can also typehans
. -
The order of the words in
NAME
does not matter. If you want to look forHans Bo
, you can also typeBo Hans
. -
Person must match contains all word in
NAME
to be returned. If you want typeBo Hans
,Hans
andBo
will not show up, butBo Yang Hans
will. -
Phone
requires to be a substring of the person. If you want to look for6593759662
you can also type93759662
. -
TAG
is case sensitive. You cannot find person with tagFRIEND
if you search fort/friend
. -
Person must match all
TAG
. If you typet/friends t/colleague
,t/friends
andt/colleague
will not show up, butt/friends t/colleague
andt/friends t/colleague t/neighbor
will. -
Person must match all fields to be returned. If you type
n/Hans p/93759662
,n/Hans p/111222
will not show up.
End of Extract
Justification
User sometimes need to lookup whose phone number or email etc. is that. With this feature, they can query any information
and get the relevant contact. NAME
is the most flexible - no order, case insensitive. The reason is that we might not
know the order we insert the user’s first and last name. For example, both Boo Kai Hsien
and Kai Hsien Boo
is equally
likely to appear in DeathNote. For the case of PHONE
, user might not know if they have input the country code or not.
Both<PHONE_NUMBER>
and 93759662
refers to the same phone. Hence taking substring is a feasible option. Finally, the design
rationale is that user are often looking for a specific person or group of persons. Hence, typing n/Amy Wong p/12345
intuitively means a person named Amy with phone number 12345.
Find Command
The implementation of find
is very similar to edit
. After the command, both requires the user to describe the target.
The matching algorithm is implemented as follows:
/** * Check {@code Person} in DeathNote against {@code this} finder target. * * @param person in DeathNote to check * @return true if other all fields matches */ public boolean match(ReadOnlyPerson person) { if (this.name != null && !matchName(this.name, person.getName())) { return false; } if (this.phone != null && !matchPhone(this.phone, person.getPhone())) { return false; } if (this.email != null && !this.email.equals(person.getEmail())) { return false; } if (this.address != null && !this.address.equals(person.getAddress())) { return false; } if (this.website != null && !this.website.equals(person.getWebsite())) { return false; } if (this.birthday != null && !this.birthday.equals(person.getBirthday())) { return false; } if (this.tags != null && !matchTag(this.tags, person.getTags())) { return false; } return true; }
Design considerations
Aspect: Component that is responsible for matchName
, matchPhone
.
Alternative 1 (current choice): Implement under FindCommand
in Logic
component.
Pros: More specific, because only FindCommand
uses it and not any other methods.
Cons: Harder to integrate if other components want to use these methods.
Alternative 2: Implement under respective Name
and Phone
class in Model
component.
Pros: Easier to integrate into other components.
Cons: Redundant as the only method that is currently using it is the find command.
End of Extract
Other contributions
-
Set up project website.
-
Add shorthand to commands.
-
Add Appveyor, Coveralls and Codeacy to the project for efficient integrations.


Archit
Arduously working towards various passions, while delivering quality code, insights, good logic and occasionally, humour; Always on the lookout for exciting stuff; Up for discussions on Metaphysics, creativity, history of Science, Aliens and of course, Technology. Here at crowd-research to build the platform (backend, data engineering) and contribute to research. Click here for my homepage.


The Events module allows you to view events in either a monthly calendar, a weekly list or as a list. All three view options are available in the default configuration, however one or more views can be disabled and the design and fields displayed in each view can also be modified. In the below images, the default configurations are used.
Important. If the Icon Bar has been disabled, unauthenticated users will be unable to change the view because access to the module actions menu is restricted to authenticated users only.
Here are the three different views that can be selected using either the module actions menu or the Event module Icon Bar:
List View: Displays events in a list.
Month View: Displays events in a monthly calendar. By default the current date is highlighted. Links to the previous month and the next month enable you view other months.
Week View: Displays events for the current week. Click the double arrow links ( << and >> ) located to scroll back and forward one week at a time.


Felipe Ballesteros
Sustaingineering
Load Voltage
3,456
Load Current
123
Power Absorbed
456K
Operating Temperature
Surface Temperature
Water Breaker
Current & Voltage
Operating & Surface Temperature
Power & Water Breaker
Summary
Settings


5 Signs That Show You’ve Got Bed Bugs in Your Home
Although bed bugs don`t actually transmit any infectious diseases, they can still be a nuisance and even cause some health problems. From physical reactions, like rash or allergy, to psychological effects, like anxiety, stress, and insomnia — these reasons are more than enough to make beg bugs unwelcome guests in your home.
Bright Side wants to help you find the bed bug infestation before it spreads, which will be easier to treat. Here are some signs you should be on the lookout for!
1. Itchy red spots
If you have skin irritation or if you notice small red itchy welts on your face, arms, legs, chest, or back, that is one sign that you have bed bugs. Those are the bites that can later become inflamed, and scratching them can lead to bleeding and infection.
To make sure that you have bed bugs and not any other kind of insects, look at the pattern of the bites. They often occur in clusters, straight rows, and zig-zag lines. However, some people might not have any physical reaction to bed bugs, so they won`t have red spots or itchiness.
2. Blood or rusty-colored stains
Check for red spots on your bed or clothes. If you squash a bug while or after it feeds, it will leave a blood stain. You might also find rusty-colored spots. Those are the bed bugs` fecal matter.
You can find this on your bed sheets, as well as in places that are harder to reach, like mattress seams, box springs, and wooden framing. Also check your walls and under the wallpaper, as bed bugs can leave fecal matter there too.
3. Musty odor
Bed bugs have scent glands that release pheromones, and if there`s a lot of them, the scent can be quite strong and unpleasant.
4. Bed bug shells
Bed bugs shed their skin when they grow, so look for light-colored husks in the shape of a bug. Inspect your bed pillows, the seams of your mattress, chairs, and couches, and between the cushions. Also make sure to check your drawers and clothes.
5. White spots on your furniture
If you see white spots on your furniture, those might be the bed bugs` eggs or eggshells. They are shaped like rice grains, and they have a translucent or white color that is sometimes shiny.
It`s possible to see them with the naked eye. But it would certainly be better to inspect your room with a flashlight and a magnifying glass, since those eggs are often laid in the joints and seams of your mattress and furniture.
Have you ever had to deal with bed bugs? How did you notice them? Please share your thoughts in the comments!
Illustrated by Igor Polushin for BrightSide.me


Coacal151.github.io
Bang amp; olufsen BeoCenter 2 Handbücher. Manuals Warehouse is your source for copies of owners manuals, service manuals and other documentation on audio, music, stage and studio equipment. Manuals list - Music and audio equipment - Manuals Warehouse.


When you work with us, you are part of a team of committed collaborators. All aspects of our software development process are integrated, interactive
and agile.
Our approach unifies design, development and project management to
create exceptional products.
We start project by understanding our business goals, the user's needs and the products requirements.
Then we help translate them into effective and elegant solutions
Before we sign a contract or write a line of code, our team will spend the necessary time needed to understand our product vision.
The outcome of this scoping session is a proposal or high-level statement of work.
Based on
your requirements, we can provide a complete offering or just the pieces you need.
Our design practice offers a full range of services including branding strategy,interaction and visual design and user experience testing. Throughout your project, our designers create and implement visual designs and workflows solicit user feedback, and work with you to make sure what gets built is what is needed.
All engineers are fluent in the latest enterprise, mobile and web development technologies. They collaborate with your team to write, test, and improve code on a daily basis using proven practices such as test-driven development and pair programming.
Planning and development is iterative. Because we are constantly coding and testing, the products we build are always ready to go live.This iterative process allows for changes as business requirements eveolve.
Portfolio
Portfolio
Portfolio
Portfolio
Portfolio
Portfolio
Portfolio
Portfolio


I feel I have always carried a sense of entrepreneurial spirit throughout my life. This sense has been there… it’s been there all along believe me, but what could I do to activate it?
It’s always been one of those feelings you get when the word is on the tip of your tongue and you just can’t spit it out. In those moments it won’t come to mind, struggling with putting the pieces together, retracing steps and reversing your memory back and forth into a wall.
That’s what this sense was like to me up until recently. Just when I could finally spit it out and feel the weight lift off my shoulders.
I had to define myself.
To define yourself you have to know what you want to do and take the steps to push in that direction. It doesn’t matter when you do it, but it matters that you find it.
“Life is all about making the decision you feel is right in the moment and learning from the experience that the decision you made results in. There is no perfect way of doing things, there are only proven ways and methods of doing things, and sometimes even those are the wrong methods for your situation.
I went to college, like everyone else.  I was pushing through a major that was just to get that piece of paper at the end of the road. I did end up graduating, but I didn’t find what defines me there.
Post college, countless jobs then-after, others telling me to get into careers they were passionate about, and failed attempt upon failed attempt at locating an actual career for myself. I figured out what work would truly define who I am.
I found freelance web development and a great community of creators doing what they love to do most.
I continually ask myself the same questions to this day.
“What exactly am I most passionate about though? What does this new found discovery push me toward? What’s next?”
Answering these questions I discovered I am most passionate about pushing the web toward a brighter future. Which brings me to Dev Anthem, a web development agency.
I believe this journey leads to the ultimate goal of creating something surrounded upon a larger idea than just a brand based upon myself. Dev Anthem is an agency not only for me, but also for my colleagues to be positive proponents of driving the future of progressive enhancement of the web.
I don’t want to be a CEO, I don’t want to be head of the board, I want to be apart of a cohort of creators building the web for the better. I continue forward with my passion for business, producing sites that are clean, minimal, easy to use, and maintainable.
I look forward to working together on your project!


RM Shaw Builders Builders opened 5 years ago with the ethos of high quality service and unique workmanship.
This positive approach is illustrated in all of the building projects we do, including our bespoke stone mason division.
With 35 years of experience in the building industry the company owner Robert Shaw has tried throughout that time to ensure your job is completed to both the clients and our satisfaction.
We will always put our customer at the heart of everything we do.
We have chosen the best tradesman to work for our company and our approach was to hand pick the right people who match our view of what RM Shaw Builders should be.
Quality, Reliability and a strong work ethic, with the client at the forefront are the company mission statement.
You are welcome to contact us to test our aims.
Stonework
Specific text to follow.
Maintenance
Specific text to follow.
Construction
Specific text to follow.


CPSC 103 - Introduction to Systematic Program Design
Python
CPSC 110 - Computation, Programs, and Programming
Racket
CPSC 121 - Models of Computation
COMM 205 - Introduction to Management Information Systems
Tableau
R/R Studio
CPSC 210 - Software Contstruction
Java
OOP
CPSC 213 - Introduction to Computer Systems
C
Assembly
Java
CPSC 221 - Basic Algorithms and Data Structures
C++
CPSC 304 - Introduction to Relational Databases
SQL
CPSC 310 - Introduction of Software Engineering
Javascript


A thread that has a queue of Message object, with the most recent message at the front.
More...
#include <Thread.h>
|
|
const unsigned int | m_id |
| | The unique identifier of the thread.
|
| |
|
list< Message * > | m_messages |
| | The messages queue that keep the most recent message at front.
|
| |
|
std::shared_ptr< spdlog::logger > | m_logger |
| | The shared logger.
|
| |
A thread that has a queue of Message object, with the most recent message at the front.
- Author
- Sevensevens
- Date
- 1/24/2016
| Thread::Thread |
( |
unsigned int |
id | ) |
|
Constructor. Initialize a Thread object with its id.
- Author
- Sevensevens
- Date
- 1/24/2016
- Parameters
-
Destructor.
- Author
- Sevensevens
- Date
- 1/24/2016
| int Thread::add |
( |
Message * |
message | ) |
|
Adds message.
- Author
- Sevensevens
- Date
- 1/24/2016
- Parameters
-
| [in,out] | message | If non-null, the message to add. |
- Returns
- An int. Returns 0 if success, otherwise 1.
| const unsigned int Thread::id |
( |
| ) |
|
Gets the id of the Thread object.
- Author
- Sevensevens
- Date
- 1/24/2016
- Returns
- An int.
Gets the string representation of the Thread object.
- Author
- Sevensevens
- Date
- 1/24/2016
- Returns
- A string.
The documentation for this class was generated from the following files:
- C:/Users/sevensevens/Desktop/github/ThreadedMessengerCpp/ThreadedMessengerCpp/ThreadedMessenger/ThreadedMessengerLib/Thread.h
- C:/Users/sevensevens/Desktop/github/ThreadedMessengerCpp/ThreadedMessengerCpp/ThreadedMessenger/ThreadedMessengerLib/Thread.cpp


 We can have a normal button for usual cases, and two more states for different ones. Because we style blocks by class selectors with BEM, we can implement them using any tags we want
Featured Regions
Featured Regions
Featured Regions


Money Play. Should Red double? If doubled, should White take?
pips Red=51 White=142
(CorrectAnswer= 0/0, ErrorScore= 0)
This is difficult to calculate over the board but see the various comments (thanks to the contributors!) for a list of shot leaving numbers. It should be clear that Red will win a lot of gammons but White will win a lot of games.
The number of checkers off is also crucial. Just one more checker off turns this from a close take to a massive pass.
As it is, it is a monster double and a scary, but perfectly correct take. Dropping gives up 0.06 equity points. If White’s checker on his 2-pt was on his ace-point (thus making the ace-point) then the take becomes trivial.
Remember, every detail matters.
The number of checkers off is also crucial. Just one more checker off turns this from a close take to a massive pass.
As it is, it is a monster double and a scary, but perfectly correct take. Dropping gives up 0.06 equity points. If White’s checker on his 2-pt was on his ace-point (thus making the ace-point) then the take becomes trivial.
Remember, every detail matters.
Cube analysis 2-ply cubeless equity +0.687 0.610 0.389 0.079 - 0.390 0.000 0.000 Cubeful equities: 1. Double, pass +1.000 2. Double, take +1.109 (+0.109) 3. No double +0.598 (-0.402) Proper cube action: Double, pass


--- layout: page title: Lean Prover Zulip Chat Archive permalink: archive/113489newmembers/23530Mapfromintersection.html ---
Hi, I'm trying to define a map from the intersection of two submodules. Let L and N be submodules of M. Then L \cap N
is a submodule of M, and L\times N
is a module. There is a map x : L \cap N
to (x,x) : L \times N
But I'm not sure how to lift x : L \cap N
to x : L
I think you should use \glb
instead of \cap
. That way you invoke the lattice structure on submodules.
@Ben McDonnell The map from L \glb N
to L
is probably called inf_le_left
.


This book is a tutorial. It aims to help you gradually learn the language. But once you’re familiar with the basics, you’ll need other sources.
The ECMA-262 specification contains the most in-depth, detailed and formalized information about JavaScript. It defines the language.
But being that formalized, it’s difficult to understand at first. So if you need the most trustworthy source of information about the language details, the specification is the right place. But it’s not for everyday use.
A new specification version is released every year. In-between these releases, the latest specification draft is at https://tc39.es/ecma262/.
To read about new bleeding-edge features, including those that are “almost standard” (so-called “stage 3”), see proposals at https://github.com/tc39/proposals.
Also, if you’re developing for the browser, then there are other specifications covered in the second part of the tutorial.
MDN (Mozilla) JavaScript Reference is the main manual with examples and other information. It’s great to get in-depth information about individual language functions, methods etc.
One can find it at https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference.
Although, it’s often best to use an internet search instead. Just use “MDN [term]” in the query, e.g. https://google.com/search?q=MDN+parseInt to search for parseInt
function.
JavaScript is a developing language, new features get added regularly.
To see their support among browser-based and other engines, see:
All these resources are useful in real-life development, as they contain valuable information about language details, their support etc.
Please remember them (or this page) for the cases when you need in-depth information about a particular feature.


Event Location:
Hilton Hotel
Charlemount Place
Dublin, , Ireland
Abstract:
At the very least, a T-SQL developer should know that the APPLY operator lets you access data from a table-valued function in a dynamic manner. But why stop there? When getting the data you need requires going around your elbow to get to your nose, that's when the savvy developer remembers the APPLY operator can be used with any table expression. Have you ever wished you could get multiple columns or multiple rows from a correlated sub-query? What about needing to UNPIVOT a data set, or parse some XML code? Have you simply wanted to find a way to handle complex calculations without having to cut and paste the entire formula in the WHERE or GROUP BY clause? This all-demo session answers those needs by revealing the secret life of APPLY, and helping you count yourself among those ace developers that use this handy operator to work smarter, not harder.
Speaker(s): Christina Leo,
Abstract:
This session will present the following topics: (1) Data architectural patterns that can be implemented in a modern Software Architecture for favoring non-functional requirements such as resource management (concurrency, even distribution) and resource demand (incremental caching, hash partitions). (2) Design techniques (like Resource Pooling, Do Not Wait / Fire and Forget , preferred caching components) and principles (like Eventual consistency, CAP theorem, Fine grained vs coased grained, Statelessness, Idempotency and fallacy of zero latency) to improve the application performance in the data access layer. This session is for Software Developers/Designers/Architects and Data Architects interested in exploring the available options
Speaker(s): Javier Caceres,
Abstract:
Microsoft released SQL Azure more than two years ago - that's enough time for testing (I hope!). So, are you ready to move your data to the Cloud? If you’re considering a business (i.e. a production environment) in the Cloud, you need to think about methods for backing up your data, a backup plan for your data and, eventually, restoring with Red Gate Cloud Services. In this session, you’ll see the differences, functionality, restrictions, and opportunities in SQL Azure and On-Premise SQL Server 2008/2008 R2/2012. We’ll consider topics such as how to be prepared for backup and restore, and which parts of a cloud environment are most important: keys, triggers, indexes, prices, security, service level agreements, etc.
Speaker(s): Tobias Koprowski,
Abstract:
The Hadoop ecosystem is a valuable tool for Business Intelligence and Data Visualisation practitioners. It allows you to mashup unstructured data from Hadoop with structured data from more traditional relational and multi-dimensional sources. For Business Intelligence practitioners, this is an excellent tool to gain new business insights, and overcome data silos that come from within the organisation, whilst freeing you to make use of external data sources too. Join us at this session in order to see how your Big Data can empower your business users via familiar Business Intelligence tools such as Excel and Power View.
Speaker(s): Jen Stirrup,
Abstract:
The BI Power Hour is a popular session at the PASS Summit and TechEd conferences that shows off the power and versatility of the Microsoft Business Intelligence stack through demos that contain little to no real world business value. Unlike most technical sessions at these conferences, the goal of the Power Hour is to entertain rather than educate. Any learning the audience experiences is purely accidental. For the past three years I’ve been a Power Hour presenter and have put together a number of demos that use SQL Server Integration Services (SSIS) in non-standard ways. This session will take a look at these demos, show how they were built, and talk about some of the key things I’ve learned while putting them together.
Speaker(s): Matt Masson,
Abstract:
XML was added to the collection of SQL Server native data types in SQL Server 2005. Being a complex data type, not only is XML accompanied by a set of dedicated T-SQL functions, but also with a complete querying language. In this session you will learn about the Microsoft SQL Server 2008 implementation of the World Wide Web Consortium's XML Query Recommendation, and learn how to compose XML data – from existing SQL Server data or simply "from scratch", how to retrieve (relational) data from XML Documents to be used in a SQL Server database, and how to manipulate XML data using Transact-SQL and the XML Data Manipulation Language (XML DML). You've already mastered all the primitive SQL Server data types, why would XML be an exception?
Speaker(s): Matija Lah,
Abstract:
Microsoft have released a distribution of Hadoop targeted at making big data accessible to everyone. Hadoop is different to SQL Server. Not necessarily better, just different. It is a tool for a job. if you have only ever worked with an RDBMS such as SQL Server then Hadoop is going to play with your mind a little and you are going to need to rethink a few things. This session is going to take Hadoop and break it apart. I will also look at some of the tooling Hive and Pig. Keep an open mind and let me show you that Hadoop has lots to offer.
Speaker(s): Allan Mitchell,
Abstract:
You’ve been given the task of optimising the File and Filegroup layout to get the most from your storage. Not sure where to start, or thinking you could get a more from your storage with a different design? Are your SAN guys telling you your storage can process 2 GB/s but you're only seeing 200 MB/s? This session will dive into how to optimise your File and Filegroup layout strategy to get the most from your I/O Subsytem, including a case study where we took a customer's table scans from 500 MB/s to 1.2 GB/s with only a change in filegroup layout. Topics covered include: - Layout for OLTP - Data Warehousing Fast Track Style - Data Warehousing on a SAN - Get data into your SSAS cubes faster (ProcessData) - Hidden options and “go faster” buttons - How to maximise performance in enterprise edition and master read ahead
Speaker(s): Stephen Archbold,
Abstract:
Why Upgrade? This is the big question that every SQL Server user will be asking, from my experience I say not just for shiny new features but increase your productivity and do-more with-less practices. Data Platform Upgrade topic has been a popular session that I've presented in major conferences like Microsoft Tech-Ed (North America, Europe India) and SQLbits. In this session, we will overview end-to-end upgrade process that covers the essential phases, steps and issues involved in upgrading SQL Server 2000, 2005, SQL Server 2008 R2 (with a good overview on 2012 too) by using best practices and available resources. We will cover the complete upgrade cycle, including the preparation tasks, upgrade tasks, and post-upgrade tasks. Real-world examples from my Consulting experience expanding on why how such a solution is offered.
Speaker(s): Satya Jayanty,
Abstract:
Want to take your skills to the next level? Then it’s critical to know SQL Server’s internal processes and architecture. This session will answer questions like:- What are the various areas of memory inside of SQL Server?- How are queries handled behind the scenes?- What does SQL Server do with procedural code, like functions, procedures, and triggers?- What happens during checkpoints? Lazywrites?- How are IOs handled with regards to transaction logs and database?This fast paced session will take you through many aspects of the internal operations of SQL Server. So strap on your silly, as we cover all these topics and more at speed with tongue planted firmly in cheek!
Speaker(s): Kevin Kline,
Abstract:
Many DBAs have heard the term Analysis Services, but don't really know what it's for or who would use it. In this session, Mark will explain the use cases for Analysis Services, illustrate how it improves performance for large data sets and eases report writing, and will go through a practical example of building a first Analysis Services solution.This session will be practical for SQL 2005 through 2008 R2, but he will also take the time to explain what changes in SQL 2012 and the new Tabular mode.
Speaker(s): Mark Stacey,
Abstract:
In this session we will address four key scenarios for customers using SQL Server in a Windows Azure Virtual machine: - Moving existing Tier 2 and Tier 3 apps to Windows Azure - Support Development and Test - Backup On-Prem Databases to the Cloud - Extend On-Prem Apps to Azure VM
Speaker(s): TBC TBC,
Abstract:
Reliable Business Intelligence is a major factor of success for any organisation. Gartner have stated that information and analytics will power revenue growth in 2013. This session will detail the integration potential between SQL Server 2012 and new release SharePoint 2013, including PowerView and Performance Point. The session will include a demo of SharePoint 2013 to demonstrate the power of SharePoint and SQL Server. As current Information Worker Solutions Partner of the Year and Microsoft Gold Business Intelligence Partners, Spanish Point have deployed highly successful Business Intelligence Projects
Speaker(s): John Corley,
Abstract:
This session will discuss the topic of an all-flash datacenter where simplified, higher density and more reliable servers make the hyperscale all-flash datacenter more efficient than datacenters based on solid state disk and hard disk systems. Find out how this changes the landscape of your datacenter and what this means for the future?
Speaker(s): Niall McLeod,
Abstract:
Database corruption is one of the worst things you can encounter as a DBA. It can result in downtime, data loss, and unhappy users. What’s scary about corruption is that it can strike out of the blue and with no warning, and without having some In this session we’ll look at • Easy maintenance operations you should be running right now to ensure the fastest possible identification and resolution of corruption • Best practices for handling a database that you suspect may be corrupted • Actions that can worsen the problem • Appropriate steps to take and methods of recovery
Speaker(s): Gail Shaw,
Abstract:
Illustrate how multipurpose queries can lead to issues with scalability and performance. Show a few alternatives that will work for smaller and simpler queries while highlighting their limitations for more complex queries. Then work through building a dynamic search query to resolve the identified performance issues. Touching on: • Testing. • Tuning each part of the query in isolation. • Plan cache re-use • Security – SQL injection attacks and authorisation / code signing. • Possibly, mentioning greater re-use and extendibility.
Speaker(s): Ian Meade,
Abstract:
In this case study we will take a sample dot.net ecommerce application running in a load test harness and show common performance worst practices, how to correct them and the impact on performance. During a series of live demos we aim to test just how far we can optimise transactional processing.This session is aimed to help developers and DBA’s understand the performance impact of choices made within a dot.net application and its interaction with SQL Server.
Speaker(s): Bob Duffy,
Abstract:
Bad habits: we all have them. SELECT * is the obvious one; but in this session you will learn about various other habits and why they can be bad for performance or maintainability. You will also learn about best practices that will help you avoid falling into some of these bad habits. Come learn how these habits develop, what kind of problems they can lead to, and how you can avoid them - leading to more efficient code, a more productive work environment, and - in a lot of cases – both.
Speaker(s): Aaron Bertrand,
Abstract:
Session Details not available
Speaker(s): n/a n/a,
Abstract:
In this session we will take an in depth look at how query plans work. We will go under the covers and see what happens when you run that query. We will also take a look at various operators, how they work, why they are chosen and how to avoid them being used in the wrong place / context,. Attendees of this session will walk away with a greater understanding of query plans and the operators, which will enable them to both better interpret their query plans and also write more efficient SQL code
Speaker(s): David Morrison,
Abstract:
Do you really understand SQL Servers’ Concurrency behaviour?  Do you believe Read operations cannot start a Transaction? Do you really know if READ UNCOMMITTED is safe for reporting? Is being Optimistic really better than being Pessimistic? Can SQL Server 2012 be the solution to all our problems or our worst nightmare? I look forward to you joining me in this very revealing and thought provoking session where I will provide answers to all these questions and more and make you wish you had known all of this sooner.
Speaker(s): Mark Broadbent,
Abstract:
SQL Server 2012 brings a wide range of changes from its previous versions - one key change is the way SQL Server memory is managed. With releases prior to SQL Server 2012, there were 2 memory managers, these have been merged into 1 with the latest version, and that’s just the start of the changes for SQL Server memory. This session will dive into questions related to memory primarily for SQL Server 2012.
Speaker(s): Neil Hambly,
Abstract:
This session looks at the most significant new functionality to be added to SSAS Multidimensional in recent years: support for the DAX language and Power View. It will show how Multidimensional models are mapped to Tabular concepts, what works and what doesn't work in DAX, how Power View works with Multidimensional models and what other benefits there are to using DAX with a Multidimensional model.
Speaker(s): Chris Webb,
Abstract:
* What do I really need * Using your investment wisely * Block Storage Technology Enhancements * Storage tiering * Flash (as cache as local)
Speaker(s): Michael Morris,
Abstract:
Various speakers will each give a 5 minute talk on a topic of their choice
Speaker(s): Variou Various,
Abstract:
This session will concentrate on explanation of how to start using and analysing the data from one of the most popular social networks - Twitter. We shall take a look at the different dashboards and we shall try to understand some of the meanings. This presentation shall try to explore the best of the existing Microsoft technologies for an accessible Twitter data analysis.
Speaker(s): Niko Neugebauer,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
Contact: http://MarkGStacey.net
Mark Stacey founded the Aphelion Software Group, and works tirelessly to cross the business/technical boundaries in Business Intelligence, working in both SharePoint and SQL. He has published two books on BI - Sharepoint 2010 BI and Visual Intelligence and frequently speaks at both SQLSaturday and SharePoint Saturday events. Mark is one of the few Microsoft PDW trainers, and has trained in Africa, India and Europe on the PDW, as well as all over the world on other technologies
LinkedIn: https://uk.linkedin.com/in/koprowskit
Contact: http://koprowskit.eu/geek/
Founder of Shadowland Consulting. In January 2015 decided to permanently leave Poland and discover new worlds. Actually settled in Hucknall (The Last home of The Byron Family). Community leader focused on SQL Server, SharePoint, security, collaboration and ITIL, DR, BCM, and SLA. Love licensing stuff. Microsoft Certified Trainer, freelancer, and consultant. Subject Matter Expert at Microsoft. Member of Microsoft Terminology Community, Friends of RedGate PLUS, PASS, ISSA, ACM and more. Since 1st July 2010 Data Platform MVP. Creator of SQLDAY Conference and Conference CEO 2009-2011. Co-Leader of PASS East Midlands Group. Speaker at group meetings and conferences. STEM Ambassador. Traveler. Coffee Addicted.
This session will be delivered by a large number of speakers of varying degrees of experience. A great time to start yourself speaking!!
LinkedIn: https://uk.linkedin.com/sqlmaster
Contact: http://www.sqlserver-qa.net
My experience surrounded with high focus on the data platform with a track record of defining strategy, designing and delivering digital transformation migrations with major enhancements to current working methods. Worked in a capacity of Head of Data Engineering, Enterprise Data Architect and Solutions Key career accomplishment recognition as an industry expert technical excellence from the Microsoft as Data Platform Most Valuable Professional (MVP) recognition since the year 2006 (13 years as MVP and counting), which recognizes exceptional technical community leaders worldwide who actively deliver, present share their extraordinary contributions, high quality, and real-world expertise. Twitter pod (http://twitter.com/sqlmast
LinkedIn: https://uk.linkedin.com/in/retracement
Contact: http://tenbulls.co.uk
Mark Broadbent is a Microsoft Certified Master in SQL Server, Chapter Leader, Virtual Chapter Leader, SQLSaturday Cambridge and SharePoint Saturday Cambridge founder (the UKs first SQLSaturday) and awarded Microsoft#39;s Community Contributor award in 2011 and the PASS Outstanding Volunteer award in 2012. Mark is a regular speaker at both International and National events and is an expert in HADR solutions, SQL Server migration, and SQL Server Concurrency control.
Contact: http://www.mattmasson.com/
Matt Masson is a Program Manager in the Information Management and Machine Learning (IMML) organization. Matt has worked on multiple data integration products, including Power Query, SSIS, DQS, MDS, and the Data Management Gateway for Power BI. He has authored two books on SSIS (Apress, and MS Press), and is a frequent presenter at Microsoft conferences. You can find his blog at http://www.mattmasson.com/.
Contact: http://jacace.wordpress.com
Javier Caceres is a Microsoft MVP in C# and Intel Black Belt Software Developer. Javier has a strong technical background in Software Architecture and Design. His areas of interest also include Net/C# and Cloud/Mobile computing. During his career He has worked as CTO, Project Manager, Software Architect, Sr Software Developer, Software Developer and Programmer. He has presented corporate session such as Microsoft Tech Days and community sessions in San Francisco/Silicon Valley.
LinkedIn: http://pt.linkedin.com/in/webcaravela/
Contact: http://www.nikoport.com
Niko Neugebauer is a Data Platform Consultant. A SQL Server MVP with over 20 years of experience in IT, he is passionate about the Microsoft Data Platform and community. Founder of the Portuguese SQL Server User Group and the main organizer of the first SQLSaturday event outside of North America (#78 Portugal), Niko speaks regularly at events such as PASS Summit, SQLRally, SQLBits, and SQLSaturday events around the world. Niko loves sharing information and knowledge and has authored over 130 blog posts on Columnstore Indexes, and regularly contributes to the open-sourced CISL library focused on Columnstore Indexes.
Contact: http://sqlinthewild.co.za
Gail Shaw is a Database Specialist focusing on database performance tuning and database recovery, with a particular interest in topics such as indexing strategies, execution plans, and writing T-SQL code that performs well and scales gracefully. Gail holds a Microsoft Certified Master certification for SQL Server 2008 and is a Data Platform MVP. She's a frequent poster on the SQLServerCentral forums, a Pluralsight author, writes articles for both SQLServerCentral.com and Simple-Talk.com, and has spoken at SQLSaturdays, SQL Bits and at the PASS Community Summit. Gail has been responsible for extending the lifespan of many an application, by performance-tuning their databases and providing technical guidance on all things SQL Server related.
Contact: http://christinaleo.net
Christina Leo is a Cloud Solution Architect at Microsoft specialising in the Data and AI Platform. Prior to joining Microsoft in 2016, she worked as an independent consultant focusing on T-SQL and BI development, as well as database performance tuning in the finance and investment banking sector. When she isn't sharing her 18 years of technical experience with the data community, you can find her racing around the Solent on a 40' sailboat or often in the Thames on a little Laser.
LinkedIn: https://www.linkedin.com/in/john-corley-73a7022/
John Corley is CTO and co-founder of Spanish Point Technologies, an award winning software company working with Microsoft technologies to provide business systems which remove complexity, increase productivity and connect users to critical business information. John has been at the forefront of delivering large scale SQL Server based solutions in Azure in the North America and Europe.
Contact: http://tsqlninja.wordpress.com
David is a senior BI consultant at Coeo. Having worked in some for of database development or another for around 14 years his areas of specialisation are sql server engine internals, tsql and query performance tuning. David has spoken at numerous conferences including several SQLBits and SQLSaturday events as well as user group meetings. He is a a confident speaker who uses humor and a down to earth approach to make even the most technical subject matters easily attainable and engagin
LinkedIn: http://lnkd.in/VC3U97
Contact: http://ianmeadedotdotdot.blogspot.ie/
TBC
Contact: http://www.jenstirrup.com
Jen is a database strategist, small business owner, SQLFamily and community advocate, public speaker and blogger. Jen was elected Director-At-Large (elect) for the Professional Association of SQL Server, responsible for the EMEA regions plus the Virtual Chapter portfolio. Jen is passionate about all things data and business intelligence, helping leaders derive value from their Microsoft SQL Server, SharePoint and Office365 investments.
LinkedIn: http://www.linkedin.com/in/kekline/
Contact: http://blogs.sentryone.com/author/kevinkline
Kevin Kline is a database and industry expert serving as Principal Program Manager at SentryOne, the industry leading SQL Server database tools vendor. A Microsoft SQL Server MVP since 2003, he is a founder and former president of PASS. Kevin is an author of many books, blogger, columnist, and popular international speaker. Kevin’s best known book is the best-selling SQL in a Nutshell and contributes monthly to Database Trends Applications magazine. He tweets at @kekline and blogs at http://Blogs.SQLSentry.com/Author/KevinKline.
Niall McLeod is technical Marketing Director EMEA for Fusion-IO
LinkedIn: http://ie.linkedin.com/in/stephenarchbold/
Contact: http://simplesql.blogspot.com
Stephen is a Microsoft Certified Master, and a Lead DBA at Arrowstreet Capital, with over 8 years experience working in SQL Server as a Production DBA and consultant. He has a focus on Performance Tuning and Consolidation to get the most from your investment in SQL Server.
Contact: http://blogs.prodata.ie/author/bob.aspx
Bob Duffy is a SQL Server MVP from Dublin, Ireland who is MCA, MCM. and Analysis Services Maestro certified. Bob works as a Database Architect at the Prodata SQL Centre of Excellence where he specializes in business intelligence and performance tuning.
Contact: https://onlysearch.wordpress.com/
Allan Mitchell is a SQL Server MVP and runs elastio, a small consultancy helping customers to make informed decisions about their data storage and integration. His focus is on enterprise search as well as real-time data integration.
LinkedIn: http://uk.linkedin.com/in/neilhambly
Contact: http://dataidol.com/NeilHambly
Neil Hambly is a SQL Server consultant, founder and consultant at Datamovements, a Gold Microsoft Data Analytics Consulting company. Neil has 20+ years in a variety of SQL Server roles and is an MCT. He is a regular presenter (200+ events) at user groups, and PASS events, including PASS Summit and SQLSaturday, and many UK events (SQLBits, SQLRelay). Neil is the leader of PASS London (UK), a Professional Development VC, a Melissa Data MVP, and a SQL Cruise Technical Lead, who loves Guinness, whisky, and dancing.
LinkedIn: http://si.linkedin.com/in/matijalah/
Contact: http://milambda.blogspot.com
Matija Lah has more than a decade of experience working with Microsoft SQL Server, mostly architecting data-centric solutions in the legal domain. His contributions to the SQL Server community have led to the Microsoft Most Valuable Professional award in 2007 (Data Platform), which he held until 2017. In 2008 Matija joined SolidQ as a Mentor, located in Central and Eastern Europe. He spends most of his time on projects involving advanced information management, and natural language processing.
Principal Solutions Engineer at EMC’s Strategic Solutions Engineering (SSE) Group. I Focus primarily on the Microsoft Applications stack, particularly SQL Server, with experience in virtualization, Cloud, Storage Design, Optimization and Flash (SSD) technology. Involved in the introduction of EMC’s Fully Automated Storage Tiering technology and experienced with EMC’s FAST Suite (FAST VP FAST Cache), XtremSF/SW, XtremIO.
Contact: https://blogs.sentryone.com/author/AaronBertrand
Aaron, Product Manager at SentryOne, produces performance and optimization tools for the entire Microsoft data platform, as well as Plan Explorer, a free tool for SQL Server execution plan analysis. In his spare time, he is either playing volleyball, curling, blogging at sqlperformance.com and blogs.sentryone.com, or contributing to SQL Server conversations on Twitter and dba.stackexchange.com. He has worked with SQL Server since 6.5 and has been an MVP since 1997.
LinkedIn: https://www.linkedin.com/in/chriswebb6/
Contact: https://blog.crossjoin.co.uk/
Chris Webb is a member of the Power BI CAT team. He is the author of "Power Query for Power BI and Excel" and a co-author of "SQL Server Analysis Services 2012: The BISM Tabular Model", "Expert Cube Development with SQL Server 2008 Analysis Services", and "MDX Solutions with Microsoft SQL Server Analysis Services 2005 and Hyperion Essbase".
The following is a list of sponsors that helped fund the event.
Spanish Point Technologies Ltd


{% if title %}
{{ title }}
{% else %}
Welcome to NewsSource!
{% endif %}
WELCOME TO NEWSAPP
Your trusted source of news!
SPORTS
FINANCE
HEALTH
Previous
Next
NEWS SOURCES
{% for source in sources %}
{{ source.name}}
{{source.description}}
Articles
{% endfor %}


PICTURED: BRITT DAVIS