The Library
Help/Info
Current Release
|
|
Last Modified:
Mar 24, 2011
|
|
Release notes
Release 17.37
Release date: Mar 24, 2011 Major Changes in this Release:
|
New Stuff:
- Added a multiclass support vector machine.
- Added a tool for solving the optimization problem associated with
structural support vector machines.
- Added new functions for dealing with sparse vectors: add_to(),
subtract_from(), max_index_plus_one(), fix_nonzero_indexing(), a
more flexible dot(), and I renamed assign_dense_to_sparse() to assign()
and made it more flexible.
Non-Backwards Compatible Changes:
- Renamed max_index_value_plus_one() (a function for working with graphs) to
max_index_plus_one() so that it uses the same name as the essentially
identical function for working with sparse vectors.
- I simplified the cross_validate_multiclass_trainer(), cross_validate_trainer(),
test_binary_decision_function(), and test_multiclass_decision_function()
routines. They now always return double matrices regardless of any other
consideration. This only breaks previous code if you had been assigning
the result into a float or long double matrix.
- Renamed assign_dense_to_sparse() to assign()
Bug fixes:
- Fixed a bug in load_libsvm_formatted_data(). I had forgotten to clear the
contents of the labels output vector before adding the loaded label data.
- Fixed a bug in the kernel_matrix() function. It didn't compile when used
with sparse samples which were of type std::vector<std::pair<> >.
Moreover, some of the trainers have a dependency on kernel_matrix() so this
fix makes those trainers also work with this kind of sparse sample.
Other:
- Added a value_type typedef to matrix_exp so it's easier to write templates
which operate on STL containers and matrix objects.
|
Release 17.36
Release date: Mar 2, 2011 Major Changes in this Release:
|
New Stuff:
- Added an implementation of the Hungarian algorithm for solving the optimal
assignment problem (in the new max_cost_assignment() routine).
Non-Backwards Compatible Changes:
Bug fixes:
- Fixed a problem which prevented the any_function unit test from compiling
in visual studio 2008.
Other:
- Changed the oca optimizer so that it warm starts the QP subproblem
rather than resolving it from scratch during each iteration. This
improves the speed and stability of the algorithm.
|
Release 17.35
Release date: Feb 10, 2011 Major Changes in this Release:
|
New Stuff:
- Added the rr_trainer. It is a version of krr_trainer which is optimized
for use with the linear_kernel.
- Added the approximate_distance_function() routine. It is the core optimizer
behind the reduced2() trainer adapter.
- Added an any_function which supports the same functionality as std::function
from the upcoming C++0x standard. I added this so dlib can be modified to
easily support lambda functions while still being compilable with compilers
which don't support the new std::function.
- Added overloads of all the GUI event handlers so you can use general functions
as callbacks (via any_function). This way, if you have a C++0x compiler, you
can use lambda functions with the event handlers.
- Added the split() function for splitting up strings.
Non-Backwards Compatible Changes:
- Improved the distance_function object by turning it into a properly
encapsulated class rather than just a simple struct. I also added
overloaded +, -, *, and / operators for this object so you can do the
kind of arithmetic you would expect on an object which represents a
point in a vector space. This breaks backwards compatibility with
the previous interface though as the member variables are now private.
Bug fixes:
- Fixed a compile-time error in the kernel_matrix().
- Fixed a bug in an assert in the spatially_filter_image() function.
- Applied a patch from Nils Labugt which fixes a runtime bug in the gui_core
component. The bug caused a crash when using X11 and Ubuntu 10.10 in
certain cases.
- Updated code so that it compiles with the clang compiler.
Other:
- Updated the image_display widget so you can zoom in and out using the
mouse wheel.
|
Release 17.34
Release date: Jan 03, 2011 Major Changes in this Release:
|
New Stuff:
- General Stuff
- Added the promote template
- Added the basic_type template
- Added the assign_image_scaled() function
- Added the unordered_pair object.
- Added the symmetric_matrix_cache() function
- Added two new quadratic program solvers. The solve_qp2_using_smo
and solve_qp3_using_smo objects.
- Machine Learning Stuff
- Added the svm_c_trainer object. It implements C-SVM classification and
allows the user to set different C values for each class.
- Added the svm_one_class_trainer object.
- Added the svr_trainer object. It implements epsilon-insensitive
support vector regression.
- Added two new any objects. The any_decision_function for containing
decision function style objects and the any_trainer for trainers.
- Added cross_validate_regression_trainer()
- Added test_regression_function()
- Added the probabilistic() function. It is a trainer adapter that
simply calls train_probabilistic_decision_function().
- Added tools for multiclass classification
- Added one_vs_one_trainer
- Added one_vs_all_trainer
- Added cross_validate_multiclass_trainer()
- Added test_multiclass_decision_function()
Non-Backwards Compatible Changes:
- invalid_svm_nu_error has been renamed to invalid_nu_error.
- Changed the pixel_traits so that signed grayscale pixel types are allowed.
This involved adding a few new fields to pixel_traits. I also changed the
get_pixel_intensity() function so that its return value is of the same type
as the basic pixel type rather than always being unsigned long.
- Removed the kernel_type typedef from the normalized function since this
meta-object should be capable of working with non-kernel decision functions.
- train_probabilistic_decision_function() no longer accepts column vectors of
samples and labels. Now it only accepts std::vectors of samples and labels.
Bug fixes:
- Fixed a bug in the deserialization code for the sparse kernels. The bug
prevented code which used the deserialize() routine from compiling.
Other:
- Changed the image display GUI widgets to use the assign_image_scaled()
function internally. Now they will accept just about any image and
do the right thing.
- Modified the type_safe_union so that you can call apply_to_contents() on const
type_safe_unions.
- Added serialization support for std::pair objects.
- Made the train_probabilistic_decision_function() more general by making it work
with any kind of trainer object rather than only ones which produce
dlib::decision_function objects. I also made it work with trainers that only
take std::vectors.
- Added overloads to the config_reader's methods to allow it to load directly
from a file name given as a string in addition to taking istream objects.
|
Release 17.33
Release date: Dec 05, 2010 Major Changes in this Release:
|
New Stuff:
- Added the ability to add/subtract scalar values to/from all the elements
of a matrix using the - and + operators.
- Added a trust region optimizer.
- Added Levenberg-Marquardt and LM/quasi-newton hybrid methods for solving
non-linear least squares problems.
- Added an any container object.
Non-Backwards Compatible Changes:
Bug fixes:
- Fixed a compiler warning and also a runtime bug in sort_basis_vectors().
The bug triggered when all the basis vectors were included in the final
answer.
Other:
- Added a bunch of overloads to catch operations on diagonal matrices
and use more efficient code paths for them. For example, inv(diagm(d))
turns into diagm(reciprocal(d)). Multiplication by a diagonal matrix
is now also handled efficiently.
|
Release 17.32
Release date: Nov 13, 2010 Major Changes in this Release:
|
New Stuff:
- Added a class for reading JPEG image files.
- Added scale_rows(), flipud() and fliplr() matrix functions.
- Added console_progress_indicator. It is a tool for measuring how long a
task will take.
- Added sort_basis_vectors(). It is a function for performing supervised
basis selection.
Non-Backwards Compatible Changes:
- Renamed the linearly_independent_subset_finder's dictionary_size() member
function to size(). This way, linearly_independent_subset_finder objects
can be used in many templated functions which expect objects which look
like arrays.
Bug fixes:
- Changed the assert macros so that they don't use __PRETTY_FUNCTION__
with gcc 4.4.5 since, on Ubuntu at least, this version of gcc segfaults
when __PRETTY_FUNCTION__ is used within certain template constructs.
- Improved the alias detection capability of kernel_matrix() expressions.
Now statements of the form: sample = kernel_matrix(kern, *, sample) can
be used since the aliasing of sample will be handled.
Other:
- Generally tried to make things more usable.
- Optimized matrix expressions such as mat*diagm(vect)
- Made the code in chol() more robust to indefinite matrices.
|
Release 17.31
Release date: Sep 15, 2010 Major Changes in this Release:
|
New Stuff:
- Added the running_scalar_covariance object.
- All the matrix decomposition routines now use LAPACK when DLIB_USE_LAPACK
is #defined.
Non-Backwards Compatible Changes:
- Removed the dlib::EOTHER constant since it conflicts with visual
studio 2010.
- Changed the svd functions so you can't supply output matrices which use
both column and row major layouts. Now all the output matrices need to
use the same memory layout.
- Removed the qr_decomposition::get_householder() function.
Bug fixes:
- Minor fixes so that dlib compiles in Visual Studio 2010
Other:
- Added an overloaded matrix_assign() that handles symmetric kernel_matrix()
expressions more efficiently by only evaluating the upper triangular part
of the matrix.
|
Release 17.30
Release date: Jul 28, 2010 Major Changes in this Release:
|
New Stuff:
Non-Backwards Compatible Changes:
Bug fixes:
- Fixed a compile-time bug in the matrix related to multiplication by
subm() expressions when the BLAS bindings were enabled.
- Fixed a bug in train_probabilistic_decision_function() which could
cause it to go into an infinite loop when working with very large
datasets.
Other:
|
Release 17.29
Release date: Jul 25, 2010 Major Changes in this Release:
|
New Stuff:
- Added a reference_wrapper implementation and modified the thread_function
slightly so it works with it.
- Added an implementation of kernel ridge regression.
- Added a simple newton search strategy for optimizing functions.
Non-Backwards Compatible Changes:
- If you have created your own matrix expressions then its possible this
new release will cause them to not compile.
Bug fixes:
- Fixed a bug in scale_columns. It said it didn't have any destructive aliasing
when in fact it destructively aliased its second argument.
- Fixed a bug in the random number generator where setting the seed back to ""
didn't result in the object going back to it's initial state.
Other:
- Reorganized the matrix expression code. It's now much simpler and the
library includes a new example program which details the steps needed to
create new matrix expressions.
- Changed the train_probabilistic_decision_function() routine so that it uses
a more numerically stable method to perform its maximum likelihood optimization.
- Added missing get/set epsilon functions to the RVM training objects.
I also changed the default epsilon from 0.0005 to 0.001.
|
Release 17.28
Release date: Jun 14, 2010 Major Changes in this Release:
|
New Stuff:
- Added the simplify_linear_decision_function() routines.
- Added the find_approximate_k_nearest_neighbors() function.
- Added the fill_lisf() function.
Non-Backwards Compatible Changes:
- Made the sample_pair have a default distance of infinity instead of
the max floating point value. I also reworked the graph creation functions
to make them a little more versatile. Now you can use infinite distances to
indicate that certain nodes are not connected at all.
- Changed the linear_manifold_regularizer to normalize the regularization
parameter by the sum of edge weights instead of the sum of edges.
Bug fixes:
- Fixed a bug in the timer_kernel_2 object. In certain rare cases it would
stop calling the action function and essentially shut down without being
told to do so.
Other:
- Made the reduced() and reduced2() functions more efficient.
- Many small usability improvements here and there.
|
Old Release Notes
|


{{ message }}
Not sent back to Node-RED - this just shows that VueJS is working
Simple VueJS Counter: {{ count }}
This is sent back to Node-RED.
Click to send msg to Node-RED
Note that including an event button in a form will automatically send all of the form inputs back to Node-RED as well.
This is sent to Node-RED when you exit it:


Primary Content Section
Roses are best known as ornamental plants grown for their flowers in the garden and sometimes indoors. Some are used as landscape plants, for hedging and for other utilitarian purposes such as game cover and slope stabilization. They also have minor medicinal uses.
Roses are best known as ornamental plants grown for their flowers in the garden and sometimes indoors. Some are used as landscape plants, for hedging and for other utilitarian purposes such as game cover and slope stabilization. They also have minor medicinal uses.
Roses are best known as ornamental plants grown for their flowers in the garden and sometimes indoors. Some are used as landscape plants, for hedging and for other utilitarian purposes such as game cover and slope stabilization. They also have minor medicinal uses.
Important Content
Roses are best known as ornamental plants grown for their flowers in the garden and sometimes indoors. Some are used as landscape plants, for hedging and for other utilitarian purposes such as game cover and slope stabilization. They also have minor medicinal uses.
Not Vital Content
Roses are best known as ornamental plants grown for their flowers in the garden and sometimes indoors. Some are used as landscape plants, for hedging and for other utilitarian purposes such as game cover and slope stabilization. They also have minor medicinal uses.
Not Vital Content
Roses are best known as ornamental plants grown for their flowers in the garden and sometimes indoors. Some are used as landscape plants, for hedging and for other utilitarian purposes such as game cover and slope stabilization. They also have minor medicinal uses.


In college I made a lot of work about place. I was fascinated by how our surroundings seep into our identities. The city is a costume, one that we all share. And you perform a different role in the city than in in the woods.
I wanted to make people look at their environments with a similar perspective to the one I had, noticing how they make you feel and the narrative they broadcast. It was a very John Cage perspective, actually, in that involved looking at the world in a raw sort of way…observing its aesthetic qualities the way you would if they were a work of art. There’s also a sense of wonder that I thought was important.
Today, I’m not sure that trying to engender this perspective is a good end for art to strive for in and of itself. Maybe it will happen along the way, but I think art should be about creating experiences, and the focus should be on the experience you’re leading someone through. I am, however, still interested in some of the tactics - discovering features in the physical world that can become compositional hooks for works that then use them as scaffolding.
I’m doing some experiments in location-based generative music.
Location-based generative music has the potential to be a something really different. There’s a bit of a gap between what I’m envisioning and where we are at, but someone someday is going to make a piece of location-based generative music that’s profound. I want to set the scene for that.
Location-based: meaning as you walk around, you hear what the artist wanted you to hear in that place. Utilizes the GPS on your smartphone.
Generative: Not every note is laid down by hand by the artist, rather a set of rules is made for a given area. Music is then digitally synthesized on the spot (pun intended).
What if you composed music for each city block within a neighborhood? A listener would be able to traverse the neighborhood how they wished, and to experience the piece they’d have to explore the relationship between the actual place and the music.
Imagine you’re walking down a busy city block. In your ears, you hear a steady cacophony in counterpoint to the sounds of the cars and people passing at random. You turn off onto a quiet side street, and the music follows suit. It’s a quiet gentle thing, but there’s a small hint at some anticipation. It builds. You turn the corner again, and are struck with a view of the water. You don’t just see it, you hear it.
Not just location, but user movement
It’s not just location though, it’s also your current activity - walking, standing still, running, riding in a car. Smartphones have accelerometer and gyroscope sensors, and iOS + Android also have higher-level API’s you can query and it will tell you what the current activity is. These are informed by black box algorithms that probably use machine learning and a bunch of other slick tricks that take a lot of the work out of working with raw sensor data.
If we know whether someone is standing still or walking, or even how fast they’re walking, we can use this information to let people perform music, too. Like say someone is standing still, and the music is in interlude. They start walking, slowly, and the music begins to crawl back up. When they get up to a brisk walk we’re really cooking again.
Another example: you’re sitting on the subway. The train slows to a stop, and the music subdues. The train starts, the music picks back up again. Next stop - the ding of the doors echoes in reverb added to your ears. When you stand, and get off the train, the piece moves to a new section. You walk up the stairs and the sonic space opens up from your cramped subterranean thing as you reach the surface.
With this I’m shooting for an uncanny digitally-mediated interaction, similar to another project of mine. I guess I like projects where I identify an idea for an interaction where A) I’ve never experienced something quite like it and B) I bet that actually doing it feels different than I imagine. There you have something worth doing, not just thinking about.
With Music for GPS, might might be like you’re playing music by walking around. I’m a musician, and there’s something amazing about how playing an instrument lets you, as you start to feel an emotion tied to the music, take an action with your body that heightens that feeling. Then on the other hand, there’s something amazing about exploring the visual world by walking through it. I just think it might be worthwhile to combine the two. When playing music, you’re moving in order to hear. When walking, you’re moving in order to see. But what if you were walking to hear as well as see? Would that be exciting? Would that be new?
[There are examples of art forms where the dancers actually control the musicians (see Bomba). But does it scale? 😜 Actually…is it private? That users will be able to do this on their own allows for a different relationship with it.]
Places have aesthetic qualities that can be really evocative, just like music. Let’s put the two together. We see this in film - with music complimenting characters’ actions and/or the setting. This is rooted in other performance media, which is why I have the opera orchestra pit as the image up top. In one respect, this project is like making a film soundtrack for real life, in real time. But also, it’s kind of like a video game in that you get to move through space exploring virtual objects, which in this case is music. It’s similar to both film and video games, but different. It’s augmented reality, but not graphical. Audio will perhaps be a major component of a wave of AR games that will surely come.
A small prototype demo
Over the summer I made a browser-based prototype. When you open the page, your precise location is recorded. Then, as you walk, your distance from that initial spot is fed into a synth, controlling a number of parameters.
You can try the demo yourself (requires being on a phone, probably outdoors), or watch the video below.
Demo page
Digital sound synthesis
I need to call out one thing - the sounds you hear for this work will be synthesized. I’m not just triggering audio clips based on inhabiting a location. The latter has been done before, and it hasn’t really taken off, and there’s a good reason.
That this will use synthesis is actually one of the key differences from prior art that will make this great. It’s about molding the music to user actions in a way that is seamless, dynamic, and ultimately more immersive. The biggest reason may be more control over timing - for example, having a phrase finish right as you reach the end of a block. The speed of your gait could set the tempo. Or, the closer you are to an object, the timbre or the way a sound is articulated could change (this is not possible with just triggering static clips).
Platform-building as instrument design
What I want to make is not just one piece of music, but a platform that many composers can use to make location-based music. Most of the the technology needed to make something really amazing already exists, but someone needs to trailblaze and assemble the pieces. There will be some holes to fill, but we won’t know what those are until someone tries. Ultimately, though, I see this as similar to creating a new instrument - there are thousands of different musical and artistic statements that could come from giving composers a set of hooks into location.
Some examples of hooks, the API of location:
GPS coordinates
“Human-readable location” AKA are you on the sidewalk? In a park?
City Data
Movement
Behavior (e.g. this person just walked down this block, but then when they turn around and retrace their steps)
Weather conditions
Time (of day, of the week, of the year)
1. What are the qualities of a location that are useful to composers?
2. Can I abstract them and make so musicians can write for them?
3. Are there certain types of musical gestures or synthesis techniques that lend themselves to being controlled with this data?
Furthermore, can we make this so that music doesn’t have to be composed for each location individually, but using location data, we render out music for large areas? Or for the whole world? This takes exploration to an extreme.
First steps:
This section is about implementation details for the first stage of this project.
A series of prototypes in:
Synthesized music,
Using gps & movement sensor data,
On iOS,
Using audiokit.
The first stage in this project is going to be a series of formative experiments / prototypes / proof of concepts into different ways to link music to location and device activity. It’s going to be a native iOS app using the AudioKit framework.
Why prototype first: Because if the eventual goal is a great work of new media art (compelling music with novel interaction paradigm scaled to a large audience), this is the first step. Discover what can be done. Get others excited about it. I’m more interested in the mechanics than the musical statement right now (there can be many musical statements made with this “instrument”), so prototypes will be about probing different interaction scenarios and laying down the foundational tech to move into more music-focused exploration.
Why iOS: Maybe it’d be better to explain why not web-based instead of native, and why not Android (or cross platform). I made an initial experiment (link) in the browser and explored several js music synthesis libraries. The libraries just don’t have the features you want to be able to make good instruments / music right off the bat. FM can only get you so far. Give me granular, give me other techniques. Give me utilities for organizing compositions. Also, the web audio API, unlike webGL for example, still has a long way to go and doen’t feel stable yet. I talked to experienced people who said differences between browsers were painful and damning - things would just sound different. Real time audio benefits from having high performance and so the web may just not be a great platform (although stay tuned for Web assembly in a few years).
Why not Android? iOS is a better platform for audio, and despite Android’s growing user base, iOS still probably holds the majority for my early adopter art/tech audience. Why not cross platform? I looked into some cross platform frameworks, and although libpd seemed somewhat feasible, it still sounded tricky. I’d love to do cross platform - iphone only is frankly a little elitist and I wish in general art apps could be cross platform when possible. But if my goal is to proof of concept for now, maybe it’d be better to choose the platform I can go the fastest and the farthest with, rather than trying to straddle two platforms out of the gate. It seems like it’d be better to come back later and port the best parts to Android, if there ends up being a need.
Why Audiokit: Out of all the libraries I looked at, it had the most features for making music. Juce looked very legit, but more focused on DSP. I just want to be able to do some experiments without spending a ton of time doing really foundational things right now. I have a feeling some of the tooling will need to be improved for my specific use-case, but Audiokit looks rigorous and people seem to like it.
Intersections
This work will intersect with a few other disciplines. It will benefit from advances in, but also could itself advance efforts in these areas:
- Computer music tech / tooling, esp on mobile.
- Geospatial data libraries and tools
- Procedural art - see the No Man’s Sky debacle. There are a lot of open questions. Challenges include making it regularly interesting and good, cause it’s often boring or bad.
- Artificial Intelligence / Machine Learning / Creative AI with regards to music creation. See Google’s Project Magenta. Basically, advances in this will make it easier to make music “in the vein of x”. Meaning less rules you have to write from scratch.
- Augmented Reality hardware / games / tooling
Problems:
Composing music within a location based workflow needs to be ironed out. For example, I want to be able to draw polygons on a map and be able to access those in an environement adjacent to my coding IDE so I can iterate quickly.
What if I don’t always want to draw everything by hand? People have done amazing work recently that may be helpful, but I need to first try and figure out what I want, and then make it.
Geo data / city may be a fruitful source material to allow for procedurally generating music that has a relationship to a given place. But how?
Most musicians, even those working with computer music, constrain themselves to traditional rhythm and harmony. That’s a mistake that would be like if jimi hendrix got a hold of an electric guitar and decided to only play classical guitar songs with no distortion. There’s a lot of musical potential and new sounds that computers allow for. This app will not make that mistake. On the other hand, I’ve experienced an academic hierarchy that says that only if you abandon melody/harmony can you make real art. It’s hostile to audiences, amounts to an erasure of culture and is bad bad bad. Toxic. I think a hybrid approach is best. Noise music, sound art, whatever you want to call it - it’s going to incorporate some of that. It’s going to have melody sometimes too. It’s going to be music.  First - goes without saying maybe that it’s only really an outdoors thing. Even outdoors, I’ll have to account for bad data, sudden huge jumps / corrections. Basically clean the data up a lot, and I fully expect it to be limiting compositionally. Tall buildings like those in Manhattan make getting a signal hard at times, too.
Computer music is haaarrrd. Need to know your tools really really well, takes a long time + big learning curve. Not sure if Audiokit has all the features I’ll want to really make great music, might need to contribute / port things over from SuperCollider or other languages. Not sure if making cross platform mobile language is ultimately feasible, because I don’t know how much you can abstract away.
Opportunity: Apple headphones will get sensors that tell you orientation, theoretically/eventually.  You’ll be able to place sound in space, and when you turn your head, the sound will stay there. Then you’ll have true augmented audio reality. What do we call this? Audi-R? Augio? AAR? I’m just excited to have sound sources that people can walk past, and it’ll be perceived as if the audio was eminating from that actual spot.
Header image credit: Flickr user ydylg under Creative Commons license.


1) Pick a fruit:
You selected {{selectedFruit.name}} which is
{{selectedFruit.color}}.
2) Pick a fruit:
The color of the selected fruit is
{{selectedFruitColor}}.
3) Pick a fruit:
You selected {{selectedFruit.name}}.
4) Pick a fruit:
You selected {{selectedFruitName}}.
5) Pick a fruit:
You selected {{selectedFruit.name}} which is
{{selectedFruit.color}}.
6) Pick a fruit:
The color of the selected fruit is
{{selectedFruitColor}}.
7) Pick a fruit:
You selected {{selectedFruit.name}} which is
{{selectedFruit.color}}.
8) Pick a fruit:
The color of the selected fruit is
{{selectedFruitColor}}.


A lot of impress.js features are and will be implemented as plugins. Each plugin has user documentation in a README.md file in its own directory.
The plugins in this directory are called default plugins, and - unsurprisingly - are enabled by default. However, most of them won't do anything by default, rather require the user to invoke them somehow. For example:
data-autoplay
to see
whether it should do its thing.

element to become visible.Yet more features are available in presentations that enable
extra addons. Extra addons are 3rd party plugins
that are not part of impress.js, but that we have nevertheless collected together into the
impress-extras repo to provide convenient and standardized access to them. To include
the extra addons when checking out impress.js, use git clone --recursive. Even then, they
are not activated by default in a presentation, rather each must be included with their own

/* Using the substep plugin, hide bullet points at first, then show them one by one. */
#impress .step .substep {
opacity: 0;
}
#impress .step .substep.substep-visible {
opacity: 1;
transition: opacity 1s;
}
/*
Speaker notes allow you to write comments within the steps, that will not
be displayed as part of the presentation. However, they will be picked up
and displayed by impressConsole.js when you press P.
*/
.notes {
display: none;
}
/* Toolbar plugin */
.impress-enabled div#impress-toolbar {
position: fixed;
right: 1px;
bottom: 1px;
opacity: 0.6;
z-index: 10;
}
.impress-enabled div#impress-toolbar > span {
margin-right: 10px;
}
.impress-enabled div#impress-toolbar.impress-toolbar-show {
display: block;
}
.impress-enabled div#impress-toolbar.impress-toolbar-hide {
display: none;
}
/* If you disable pointer-events (like in the impress.js official demo), you need to re-enable them for the toolbar.
And the speaker console while at it.*/
.impress-enabled #impress-toolbar { pointer-events: auto }
.impress-enabled #impress-console-button { pointer-events: auto }
/* Progress bar */
.impress-enabled .impress-progressbar {
position: absolute;
right: 318px;
bottom: 1px;
left: 118px;
border-radius: 7px;
border: 2px solid rgba(100, 100, 100, 0.2);
}
.impress-enabled .impress-progressbar DIV {
width: 0;
height: 2px;
border-radius: 5px;
background: rgba(75, 75, 75, 0.4);
transition: width 1s linear;
}
.impress-enabled .impress-progress {
position: absolute;
left: 59px;
bottom: 1px;
text-align: left;
opacity: 0.6;
}
.impress-enabled #impress-help {
background: none repeat scroll 0 0 rgba(0, 0, 0, 0.5);
color: #EEEEEE;
font-size: 80%;
position: fixed;
left: 2em;
bottom: 2em;
width: 24em;
border-radius: 1em;
padding: 1em;
text-align: center;
z-index: 100;
font-family: Verdana, Arial, Sans;
}
.impress-enabled #impress-help td {
padding-left: 1em;
padding-right: 1em;
}
The vision for impress.js is to provide a compact core library doing the actual presentations, with a collection of plugins that provide additional functionality. A default set of plugins are distributed together with the core impress.js, and are located in this directory. They are called default plugins because they are distributed and active when users use the js/impress.js in their presentations.
The common way to use impress.js is to link to the file
js/impress.js. This is a simple concatenation of the
core impress.js and all plugins in this directory. If you edit or add code
under src/, you can run node build.js
to recreate the distributable
js/impress.js
file. The build script also creates a minified file, but this
is not included in the git repository.
If your code has parse errors, the build.js
will print a rather unhelpful
exception like
/home/hingo/hacking/impress.js/js/impress.js
/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:271
throw new JS_Parse_Error(message, line, col, pos);
^
Error
at new JS_Parse_Error (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:263:18)
at js_error (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:271:11)
at croak (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:733:9)
at token_error (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:740:9)
at unexpected (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:746:9)
at Object.semicolon [as 1] (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:766:43)
at prog1 (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:1314:21)
at simple_statement (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:906:27)
at /home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:814:19
at block_ (/home/hingo/hacking/impress.js/node_modules/uglify-js/lib/parse-js.js:1003:20)
You will be pleased to know, that the concatenation of the unminified file js/impress.js has already succeeded at this point. Just open a test in your browser, and the browser will show you the line and error.
Each plugin is contained within its own directory. The name of the directory is the name of the plugin. For example, imagine a plugin called pluginA:
src/plugins/plugina/
The main javascript file should use the directory name as its root name:
src/plugins/plugina/plugina.js
For most plugins, a single .js
file is enough.
Note that the plugin name is also used as a namespace for various things. For
example, the autoplay plugin can be configured by setting the data-autoplay="5"
attribute on a div
.
As a general rule ids, classes and attributes within the div#impress
root
element, may use the plugin name directly (e.g. data-autoplay="5"
). However,
outside of the root element, you should use impress-pluginname
(e.g.

. The latter (longer) form also applies to all
events, they should be prefixed with impress:pluginname
.
You should use crisp and descriptive names for your plugins. But
sometimes you might optimize for a short namespace. Hence, the
Relative Positioning Plugin is called rel
to keep html attributes
short. You should not overuse this idea!
Note that for default plugins, which is all plugins in this directory, NO css, html or image files are allowed.
Default plugins must not add any global variables.
The plugin directory should also include tests, which should use the QUnit and
Syn libraries under test/. You can have as many tests as you like,
but it is suggested your first and main test file is called plugina_tests.html
and plugina_tests.js
respectively. You need to add your test .js
file into
/qunit_test_runner.html, and the .js
file
should start by loading the test .html
file into the
iframe#presentation-iframe
. See navigation-ui plugin for an
example.
You are allowed to test your plugin whatever way you like, but the general approach is for the test to load the js/impress.js file produced by build.js. This way you are testing what users will actually be using, rather than the uncompiled source code.
To avoid polluting the global namespace, plugins must encapsulate them in the standard javascript anonymous function:
/**
* Plugin A - An example plugin
*
* Description...
*
* Copyright 2016 Firstname Lastname, email or github handle
* Released under the MIT license.
*/
(function ( document, window ) {
// Plugin implementation...
})(document, window);
We categorize plugins into various categories, based on how and when they are called, and what they do.
An init plugin is the simplest kind of plugin. It simply listens for the
impress().init()
method to send the impress:init
event, at which point
the plugin can initialize itself and start doing whatever it does, for example
by calling methods in the public api returned by impress()
.
The impress:init
event has the div#impress
element as its target
attribute,
whereas event.detail.api
contains the same object that is returned by calling
impress()
. It is customary to store the api object sent by the event rather than
calling impress()
from the global namespace.
Example:
/**
* Plugin A - An example plugin
*
* Description...
*
* Copyright 2016 Firstname Lastname, email or github handle
* Released under the MIT license.
*/
(function ( document, window ) {
var root;
var api;
var lib;
document.addEventListener( "impress:init", function( event ) {
root = event.target;
api = event.detail.api;
lib = api.lib;
// Element attributes starting with "data-", become available under
// element.dataset. In addition hyphenized words become camelCased.
var data = root.dataset;
// Get value of `<div id="impress" data-plugina-foo="...">`
var foo = data.pluginaFoo;
// ...
}
})(document, window);
Both Navigation and Autoplay are init plugins.
To provide end user configurability in your plugin, a good idea might be to
read html attributes from the impress presentation. The
Autoplay plugin does exactly this, you can provide
a default value in the div#impress
element, or in each div.step
.
A plugin must only use html attributes in its designated namespace, which is
data-pluginName-*="value"
For example, if pluginA offers config options foo
and bar
, it would look
like this:

Some plugins need to run before even impress().init() does anything. These are typically filters: they want to modify the html via DOM calls, before impress.js core parses the presentation. We call these pre-init plugins.
A pre-init plugin must be called synchronously, before impress().init()
is
executed. Plugins can register themselves to be called in the pre-init phase
by calling:
impress.addPreInitPlugin( plugin [, weight] );
The argument plugin
must be a function. weight
is optional and defaults to
10
. Plugins are ordered by weight when they are executed, with lower weight
first.
The Relative Positioning Plugin is an example of a pre-init plugin.
A pre-stepleave plugin is called synchronously from impress.js core at the
beginning of impress().goto()
.
To register a plugin, call
impress.addPreStepLeavePlugin( plugin [, weight] );
When the plugin function is executed, it will be passed an argument
that resembles the event
object from DOM event handlers:
event.target
contains the current step, which we are about to leave.
event.detail.next
contains the element we are about to transition to.
event.detail.reason
contains a string, one of "next", "prev" or "goto",
which tells you which API function was called to initiate the transition.
event.detail.transitionDuration
contains the transitionDuration for the
upcoming transition.
A pre-stepleave plugin may alter the values in event.detail
(except for
reason
), and this can change the behavior of the upcoming transition.
For example, the goto
plugin will set the event.detail.next
to point to
some other element, causing the presentation to jump to that step instead.
A GUI plugin is actually just an init plugin, but is a special category that exposes visible widgets or effects in the presentation. For example, it might provide clickable buttons to go to the next and previous slide.
Note that all plugins shipped in the default set must not produce any visible html elements unless the user asks for it. A recommended best practice is to let the user add a div element, with an id equaling the plugin's namespace, in the place where he wants to see whatever visual UI elements the plugin is providing:

Another way to show the elements of a UI plugin might be by allowing the user to explicitly press a key, like "H" for a help dialog.
Toolbar plugin is an example of a GUI plugin. It presents a toolbar where other plugins can add their buttons in a centralized fashion.
Remember that for default plugins, even GUI plugins, no html files, css files or images are allowed. Everything must be generated from javascript. The idea is that users can theme widgets with their own CSS. (A plugin is of course welcome to provide example CSS that can be copypasted :-)
If pluginB depends on the existence of pluginA, and also pluginA must run
before pluginB, then pluginB should not listen to the impress:init
event,
rather pluginA should send its own init event, which pluginB listens to.
Example:
// pluginA
document.addEventListener("impress:init", function (event) {
// plugin A does it's own initialization first...
// Signal other plugins that plugin A is now initialized
var root = document.querySelector( "div#impress" );
var event = document.createEvent("CustomEvent");
event.initCustomEvent("impress:plugina:init', true, true, { "plugina" : "data..." });
root.dispatchEvent(event);
}, false);
// pluginB
document.addEventListener("impress:plugina:init", function (event) {
// plugin B implementation
}, false);
A plugin should use the namespace impress:pluginname:*
for any events it sends.
In theory all plugins could always send an init
and other events, but in
practice we're adding them on an as needed basis.


Defining naming conventions is key to make it possible for a team to efficiently collaborate. All method names must match the provided regular expression.
With default provided regular expression: ^[a-z][a-zA-Z0-9]+$
class MyClass: private boolean 2myMethod: return boolean #Noncompliant type return
class MyClass: private boolean myMethod: return boolean #Noncompliant type return


Top Places
I
like
(mostly National Parks)
Yosemite National Park
Zion National Park
Olympic National Park
And so many more!


Wordlists
https://github.com/danielmiessler/SecLists
Fuzzlists
https://github.com/fuzzdb-project/fuzzdb
Resources
http://docs.alexomar.com/?dir=biblioteca
https://github.com/Hack-with-Github/Free-Security-eBooks#offensive-security
https://github.com/lcatro/Hacker_Document
Homoglyphs
https://www.irongeek.com/homoglyph-attack-generator.php
Cheatsheets
https://github.com/MMquant/PayloadsAllTheThings
Encoder/Decoder/Requester/Extractor
https://gchq.github.io/
Blogs
https://philippeharewood.com/
https://blog.rapid7.com/
https://blog.it-securityguard.com/
https://portswigger.net/blog/
https://nvisium.com/category/blog/
https://blog.zsec.uk/
http://brutelogic.com.br/blog/
https://www.bugcrowd.com/about/blog/
https://www.hackerone.com/blog
https://rhinosecuritylabs.com/blog/


INTER GREEN
Menu1
Menu2
Menu3
Menu4
Menu5
Suspendisse interdum return nise
Left
Center
Right
Featured Products
Book Name:
Writing master:
BUY
Book Name:
Writing master:
BUY
Book Name:
Writing master:
BUY
Book Name:
Writing master:
BUY


Layered application is software architectural approach. In this article provides details on Layered application approach with examples.
Process flow is a representation of path that will be taken by user input until it reaches data store.
It is advised to start with generic layering structure and evolve to accept process flow.
Generic layering involves separation of screens from logic and logic from data storage.
Layers contains a range of software entities from a few lines of code to set of applications. For instance, in new microservices architectural approach;
Generic layering involves separation of screens from logic and logic from data storage.
Communication is done using finalized contracts between involved layers. These contracts are essentially data structure used to pass information. Mostly, the contracts are formatted into XML or json (simplified XML) or Class objects.Contracts for layer communication is explained in future blogs. Please do care to have a look.


{% extends 'account/base.html' %} {% block title %} Password Change {% endblock title %} {% block content %}
Your password has been succesfully changed.


Installing Software
Move your mouse to the "Software" button in the menu above, and then click on your operating system in the drop-down menu for instructions on installing the KISS IDE on your computer.
Classroom Activities
Click the "Activities" selection in the above navigation menu to see robotics activities.
Resources
Click the "Resources" selection in the above navigation menu to see KIPR resources, including the KIPR Link manual, the Sensor & Motor manual, the Art of Lego Design, and the Windows 7 Installation Troubleshooter.


We are Group 7Committed to predicting electricity prices, we are in action
1 hour ahead
1 day ahead
1 week ahead
Work
created with


Brachse (Goldbrasse - Biozucht)
Also called daurade or dorada, a popular Mediterranean fish that is unfortunately farmed in an environmentally damaging way - but organic certified Gilthead Bream is fine according to the MCS.
← Back to list of fishes
Sources:
The MCS rates organic farmed gilthead bream as a 2, but other kinds of bream as a 4-5. The Monterey Bay Aquarium lists gilthead farmed in closed tanks as a Best Choice.


|
Robot
The embedded systems for UTRA's autonomous humanoid soccer-playing robot
|
Public Member Functions | |
| void | setUartInterface (UartInterface *hw_if, UART_HandleTypeDef *uartHandlePtr) |
| Initializes the handle to the low-level hardware routines, and associates a particular UART module on the board with this driver. More... | |
| void | setOSInterface (FreeRTOSInterface *os_if) |
| Initializes the handle to the system calls provided by the OS. More... | |
| void | setIOType (IO_Type io_type) |
| Configures the driver to use a particular IO type. This is used to change it between using blocking and asynchronous transfers. More... | |
| IO_Type | getIOType (void) const |
| Returns the IO type currently being used by the driver. More... | |
| bool | transmit (uint8_t *arrTransmit, size_t numBytes) const |
| Instruct the driver to transmit data from the UART that was set by setUartInterface, and using the IO transfer mode set by setIOType. More... | |
| bool | receive (uint8_t *arrReceive, size_t numBytes) const |
| Instruct the driver to receive data from the UART that was set by setUartInterface, and using the IO transfer mode set by setIOType. More... | |
Private Attributes | |
| IO_Type | io_type = IO_Type::POLL |
| IO Type used by the driver, i.e. whether the driver uses polled, interrupt-driven, or DMA-driven IO. | |
| UartInterface * | hw_if = nullptr |
| Pointer to the object handling direct calls to the UART hardware. | |
| bool | hw_is_initialized = false |
| true if the UartInterface has been set and its UART_HandleTypeDef pointer has been set, otherwise false | |
| FreeRTOSInterface * | os_if = nullptr |
| Pointer to the object handling system calls to the OS. | |
Static Private Attributes | |
| static constexpr uint32_t | POLLED_TRANSFER_TIMEOUT = pdMS_TO_TICKS(2) |
| Maximum time allowed for a polled IO transfer. | |
| static constexpr TickType_t | MAX_BLOCK_TIME = pdMS_TO_TICKS(2) |
| Maximum time allowed for a thread to block on an asynchronous transfer. | |
usage of a particular UART, taking care of hardware-level calls, OS-level calls, and passing up statuses. OS support is selected at compile time based on whether the THREADED macro is defined
Definition at line 43 of file UartDriver.h.
| IO_Type UART::UartDriver::getIOType | ( | void | ) | const |
Returns the IO type currently being used by the driver.
Definition at line 61 of file UartDriver.cpp.
| bool UART::UartDriver::receive | ( | uint8_t * | arrReceive, |
| size_t | numBytes | ||
| ) | const |
Instruct the driver to receive data from the UART that was set by setUartInterface, and using the IO transfer mode set by setIOType.
| arrReceive | The byte array which the received data is to be written into |
| numBytes | The number of bytes to be received |
Definition at line 116 of file UartDriver.cpp.
| void UART::UartDriver::setIOType | ( | IO_Type | io_type | ) |
Configures the driver to use a particular IO type. This is used to change it between using blocking and asynchronous transfers.
| io_type | The type of IO to be used by the driver |
Definition at line 57 of file UartDriver.cpp.
| void UART::UartDriver::setOSInterface | ( | FreeRTOSInterface * | os_if | ) |
Initializes the handle to the system calls provided by the OS.
| os_if | Pointer to the object handling the calls to the OS |
| void UART::UartDriver::setUartInterface | ( | UartInterface * | hw_if, |
| UART_HandleTypeDef * | uartHandlePtr | ||
| ) |
Initializes the handle to the low-level hardware routines, and associates a particular UART module on the board with this driver.
| hw_if | Pointer to the hardware-facing object handling the low-level UART routines |
| uartHandlePtr | Pointer to a structure that contains the configuration information for the desired UART module |
Definition at line 35 of file UartDriver.cpp.
| bool UART::UartDriver::transmit | ( | uint8_t * | arrTransmit, |
| size_t | numBytes | ||
| ) | const |
Instruct the driver to transmit data from the UART that was set by setUartInterface, and using the IO transfer mode set by setIOType.
| arrTransmit | The byte array to be sent |
| numBytes | The number of bytes to be sent from the array |
Definition at line 65 of file UartDriver.cpp.


Before Change
with pytest.raises(vol.Invalid):
schema(value)
with tempfile.TemporaryDirectory() as tmp_path:
tmp_file = os.path.join(tmp_path, "test.txt")
with open(tmp_file, "w") as tmp_handl:
tmp_handl.write("test file")
schema(tmp_file)
def test_url():
Test URL.
schema = vol.Schema(cv.url)
After Change
// patching methods that allow us to fake a file existing
// with write access
with patch("os.path.isfile", Mock(return_value=True)), \
patch("os.access", Mock(return_value=True)):
schema("test.txt")
def test_url():
Test URL.
schema = vol.Schema(cv.url)


{{ event.name }}
{{ event.event-start-date | date: "%a %-d %b, %Y" }}{% if event.event-end-date %} – {{ event.event-end-date | date: "%a %-d %b, %Y" }}{% endif %}{% if event.event-start-time %}, {{ event.event-start-time }}{% endif %}
--- title: "Online and streamed events" layout: featured header-bg: custom-bg-corporate featured-hero-description: "Enjoy live streamed and recorded library events & book groups from your home." featured-hero-image: "home/storytime.jpg" featured-hero-alt: "A girl watching a woman tell a story on TV." featured-hero-caption: "Southwold Library’s story time live streamed" breadcrumb: home pad-content: true ---
{{ event.event-start-date | date: "%a %-d %b, %Y" }}{% if event.event-end-date %} – {{ event.event-end-date | date: "%a %-d %b, %Y" }}{% endif %}{% if event.event-start-time %}, {{ event.event-start-time }}{% endif %}
{% if event.recurrent-day %}{{ event.recurrent-day }}{% endif %}{% if event.recurrent-times %} {{ event.recurrent-times }}{% endif %}
{% if event.recurrent-description %}{{ event.recurrent-description}}
{% endif %}


Chapter 10 Participants
The “Participants” view is one way to access participant information. It is very similar to the “Participant search” view, and it is mostly down to personal preference on which to use. You can customize “Participant search” to show exactly the data you want to see, while “Participants” is predefined and more simplistic. One important difference remains, however: the “Groups” tab, which only exists under “Participants.”
Depending on which project is selected in the dropdown in the main menu, the result in the “Participants” view will differ. If a specific project is selected, only participants in that project wil be shown under each tab.
In “Participants,” there are four tabs:
- My participants, which shows you any participants assigned to you (as a therapist)
- Supervisions, which is similiar to “Supervised participants”
- All participants, which shows you all participants in a project. If no project is selected, it will show all participants in the database.
- Groups, which shows you the groups created in a project, and gives you the tools to manage them.
10.1 Creating, deleting and editing participants
You can create new participants in two of the tabs in the Participants view; My participants and All participants. Participants that are created in the My participants tab will be tagged as your participants automatically, while participants created in the All participants tab won’t be tagged. To create a new participant, click Create participant within project [Project Name]. Newly created participants are added at the bottom of each view.
To delete at participant, click the trash bin icon to the far right of the corresponding participant’s row.
To edit a participant, click the pencil icon in the table, on the corresponding participant’s row. This will take you to the “Participant stats” view.
If you only wish to change, or add, what group a participant belongs to, you can do so directly in the Group column of the participant table by using the dropdown. When you’ve assigned a participant to a group this way, don’t forget to click the “Save” button at the bottom of the table.
10.2 The participant view
When you create or edit a participant, the participant view is shown. To exit this view, and return to the participants table, click the “close” text to the right of the participant’s name. If you made any changes to the participant, don’t forget to save them by clicking the “Save” button at the bottom of the page.
There are seven tabs in this view:
- Participants stats, where you can view all fundamental information on the participant
- Treatments, where you can view and manage any treatments connected to the participant
- Files, where you can upload files relevant to the participant. These files cannot be viewed by the participant, but only by therapist who have access to the participant.
- External messages, where you can manually send SMS or e-mail messages to the participant, and review the status on any previously sent external messages.
- Flags, where you can view any flags the participant might have.
- Assessments, where you can view and manage assessments for the participant. You can also activate or deactivate individually managed assessment through this view.
- Graphs, where you can see graphs on the answers the participant has given on recurring assessments.
10.2.1 Participant stats
This view shows information about the participant, such as ID-numbers, name, the therapist assigned to the participant (if any), any notes on the participant and more.
Now notes on a participant can be added by clicking the Create new note link.
Important note:Prior to doing this for the first time, make sure to add at least one note category through the Note categories, accesssed from the main menu. Further details on this can be found in the Participant notes section in this manual.
The Stats box shows data such as how many times the participant has logged in and which privacy consent was approved and when. Internal ID is the identification number of the participant used by the database.
User information can be edited in the User information box.
Existing passwords cannot be retrieved, only cleared or changed. If a participant reports a lost or forgotten password, you can provide them with a link to reset and change their password by clicking the Send password link button.
It is also possible to generate new quick login codes, and to send them by SMS, from this view.
Important note: Quick login settings are managed under Security settings in the main menu.
Important note: Exempt from two-factor authentication must be enabled under Project security in the main menu. Only participants can be exempt from two-factor authentication. It is mandatory for therapists.
The Temporary flag text box provides you with the possibility to flag a participant with a star icon, that will display next to their name in the participants table. You can add a comment on why you flagged the participant.
The Temporary notes box provides you with the possibility to add a temporary note on the participant - this note is also saved in the participant log if your click the “Save” button.
Assign participant to therapists allows you to assign the participant to another, or several other, therapist(s). The number shown in brackets to the right of each therapist’s name displays how many participants are already assigned to that therapist. This is useful for when you want to assign participants equally to the available therapists.
Remember to click “Save” to save your changes.
You can use the dropdown menu on the bottom of the page to move the participant to another project. This will move the participant to the project of your choosing, and close the tab. If you want top view the participant again, you will need to navigate to the destination project before being able to do so.
10.2.2 Participant treatments
To assign a participant to an existing treatment, go to Participants, Treatments, the Treatment access tab. All available treatments are listed here in the dropdown menu.
If a treatment doesn’t show up in the dropdown menu, you will have to make it available via Treatment containers in the main menu.
Important note: While it technically is possible to assign several treatments to the same participant via the admin interface, the participate will only be able to access one of the treatments at a time.
In some studies, you may want to record how much time is spent writing messages to participants by a therapist. More info to come


Inspired by my Service Jam win, my colleague and I decided to introduce a similar intiative in the workplace to encourage creative ideas, innovation and collaboration at work. We called it “Bagel Morning”, which involves a sumptuous bagel, its cream cheese culprit and coffee.
For our first test, we launched the first Bagel Morning amongst a few colleagues we collaborate with on a regular basis including design leads, project managers, designers and a customer experience specialist.
Based on our existing collaborations, we decided to address design principles as a first topic. At that moment in time, our shared pain point is in the different processes and protocols when launching features for projects, from the mobile app to redesigning the desktop experience. As our products evolved, we needed a set of standards and principles to guide us and fall back on.
We started by looking at examples of other design practices such as Airbnb on "Belong Anywhere", Microsoft's inclusive design and Google's material design. Subsequently, we discussed our pain points and used those as pointers for agreeing on the principles that are most relevant for us and our work.
At the end of the session, we walked away with six key design principles. As a first test, the Bagel Morning workshop generated very positive feedback and they actually wanted to have these workshops more often.
The fun part about designing workshops is that I get to learn too. I've always had a knack for storytelling through my work but deducing them to theories and techniques was not something I thought about consciously. We looked through different academic materials and even enrolled in Pixar's storytelling course to get a sense of how to structure the course.
Storytelling has many contexts. It can be for entertainment, business pitches, user engagement or simply just recounting a recent trip in Iceland.
The thing about innovation is it doesn't have to be inventing a completely new product or experience. Sometimes, simplifying or improving the core part of it is already innovation in and of itself.
The best part is everyone's got it in them. It's just a matter of taking gradual steps and a mindset that needs to be nurtured.
As with all designs, even workshops need iteration.
Special thanks to Weining Ding for the cute illustrations.
Our invitations for Bagel Mornings. The answer to the movie is Beauty and the Beast in case you're wondering :)
This is the heart of data-driven design and could not have been done without either the engagement nor the quantitative propensity model. In fact, this approach maximized our reach and acquisition.


akar-icons
air
airplay-audio
airplay-video
airpods
alarm
align-bottom
align-horizontal-center
align-left
align-right
align-to-bottom
align-to-middle
align-to-top
align-top
align-vertical-center
android-fill
angular-fill
arrow-back-thick-fill
arrow-back-thick
arrow-back
arrow-clockwise
arrow-counter-clockwise
arrow-cycle
arrow-down-left
arrow-down-right
arrow-down-thick
arrow-down
arrow-forward-thick-fill
arrow-forward-thick
arrow-forward
arrow-left-thick
arrow-left
arrow-repeat
arrow-right-left
arrow-right-thick
arrow-right
arrow-shuffle
arrow-up-down
arrow-up-left
arrow-up-right
arrow-up-thick
arrow-up
attach
backspace-fill
backspace
basket
battery-charging
battery-empty
battery-full
battery-low
battery-medium
bell
bicycle
bitcoin-fill
block
bluetooth
book
bootstrap-fill
box
bug
calculator
calendar
camera
cart
chat-add
chat-approve
chat-bubble
chat-dots
chat-edit
chat-error
chat-question
chat-remove
check-box-fill
check-box
check
chess
chevron-down
chevron-horizontal
chevron-left
chevron-right
chevron-up
chevron-vertical
circle-alert-fill
circle-alert
circle-check-fill
circle-check
circle-chevron-down-fill
circle-chevron-down
circle-chevron-left-fill
circle-chevron-left
circle-chevron-right-fill
circle-chevron-right
circle-chevron-up-fill
circle-chevron-up
circle-fill
circle-minus-fill
circle-minus
circle-plus-fill
circle-plus
circle-triangle-down-fill
circle-triangle-down
circle-triangle-left-fill
circle-triangle-left
circle-triangle-right-fill
circle-triangle-right
circle-triangle-up-fill
circle-triangle-up
circle-x-fill
circle-x
circle
clipboard
clock
cloud-download
cloud-upload
cloud
codepen-fill
coffee
coin
command
computing
copy
credit-card
cross
css-fill
cursor
desktop-device
devices
diamond
discord-fill
django-fill
door
dot-grid-fill
double-check
download
draft
drag-horizontal-fill
drag-vertical-fill
dribbble-fill
dropbox-fill
edit
enlarge
envelope
eye-closed
eye-open
eye-slashed
face-happy
face-neutral
face-sad
face-very-happy
face-very-sad
face-wink
facebook-fill
figma-fill
file
fire
flag
flashlight
folder-add
folder
frame
full-screen
game-controller
gatsby-fill
gear
gift
github-fill
glasses
globe
google-contained-fill
google-fill
graphql-fill
grid
hand
hashtag
headphone
health
heart
height
heptagon-fill
heptagon
hexagon-fill
hexagon
home
html-fill
image
inbox
infinite
info-fill
info
instagram-fill
jar
javascript-fill
jquery-fill
key-cap
laptop-device
leaf
lifesaver
light-bulb
link-chain
link-off
link-on
link-out
linkedInV1-fill
linkedInV2-fill
location
lock-off
lock-on
map
medium-fill
mention
microphone
miniplayer
minus
mobile-device
money
moon-fill
moon
more-horizontal-fill
more-vertical-fill
network
newspaper
nextjs-fill
node-fill
normal-screen
npm-fill
octagon-fill
octagon
octocat-fill
open-envelope
oval
paper
parallelogram
pause
pencil
pentagon-fill
pentagon
people-group
people-multiple
person-add
person-check
person-cross
person
phone
php-fill
pin
pinterest-fill
plane-fill
plane
planet
plant
play
plus
pointer-down-fill
pointer-left-fill
pointer-right-fill
pointer-up-fill
pointing-up
python-fill
question-fill
question
radish
react-fill
reddit-fill
reduce
redux-fill
ribbon
rock-on
rss
sass-fill
schedule
scissor
search
send
share-box
shield
shipping-box-v1
shipping-box-v2
shopping-bag
sign-out
slack-fill
slice
snapchat-fill
sound-down
sound-off
sound-on
sound-up
soundcloud-fill
spotify-fill
square-fill
square
stack-overflow-fill
star
stop-fill
stop
sun-fill
sun
tablet-device
tag
telegram-fill
telescope
tetragon-fill
tetragon
text-align-center
text-align-justified
text-align-left
text-align-right
three-line-horizontal
three-line-vertical
thumbs-down
thumbs-up
thunder
ticket
toggle-off-fill
toggle-off
toggle-on-fill
toggle-on
togo-cup
trash-bin
trash-can
triangle-alert-fill
triangle-alert
triangle-down
triangle-fill
triangle-left
triangle-right
triangle-up
triangle
trophy
truck
tumblr-fill
twitch-fill
twitter-fill
two-line-horizontal
two-line-vertical
umbrella
utensils
vape-kit
vercel-fill
victory-hand
vimeo-fill
vk-fill
vr-ar
vscode-fill
vue-fill
wallet
watch-device
water
whatsapp-fill
width
wifi
wine-glass
yarn-fill
youtube-fill
zoom-fill
zoom-in
zoom-out


import { isArray, isString, last } from "../utils"
import { ERR_EXPECT_PATTERN, ERR_EXPECT_STRING } from "../vm"
import { isArray, isString, last } from "../utils"
import { ERR_EXPECT_PATTERN, ERR_EXPECT_STRING } from "../vm"
The standard library include basic (arithmetic, logic, etc.) commands
wrap A modulo operation that handles negative n more appropriately e.g. wrap(-1, 3) returns 2 see http://en.wikipedia.org/wiki/Modulo_operation see also http://jsperf.com/modulo-for-negative-numbers
const wrap = (a, b) => (a % b + b) % b
op1 A generic stack operation that pops one value and pushes on result
const op1 = fn => ({ stack }) => {
stack.push(fn(stack.pop()))
}
op2 A generic stack operation that pops two values and pushes one result
const op2 = fn => ({ stack }) => {
stack.push(fn(stack.pop(), stack.pop()))
}
export default {
@+, @add: Add two values
[1, 2, "@+"]
"@+": op2((b, a) => a + b),
"@add": "@+",
@-, @sub: Subtract two values
[2, 1, "@-"]
"@-": op2((b, a) => a - b),
"@sub": "@-",
@*, @mul: Multiply two values
[2, 4, "@*"]
"@*": op2((b, a) => a * b),
"@mul": "@*",
@/, @div: Divide two values
[4, 2, "@/"]
"@/": op2((b, a) => b === 0 ? 0 : a / b),
"@div": "@/",
@%, @wrap: Modulo for positive and negative numbers
[4, -2, "@%"]
"@%": op2((b, a) => b === 0 ? 0 : wrap(a, b)),
"@wrap": "@%",
@mod: Standard modulo operation
[4, 2, "@mod"]
"@mod": op2((b, a) => b === 0 ? 0 : a % b),
@neg: The negative of a value
[4, "@neg"]
"@neg": op1(a => -a),
@cond: Conditional execution
[true, "@cond", [<success pattern>], [<fail pattern>]]
"@cond": ({ stack, operations }) => {
const test = stack.pop()
this is the pattern to execute if the test passes
const success = operations.pop()
the next pattern is the “else” part
if (test) {
remove the “else” part
operations.pop()
operations.push(success)
}
},
@>: Greater than
"@>": op2((b, a) => a > b),
@>=: Greater or equal than
"@>=": op2((b, a) => a >= b),
@<: Less than
"@<": op2((b, a) => a < b),
@<=: Less or equal than
"@<=": op2((b, a) => a <= b),
@==: Is equal
"@==": op2((b, a) => a === b),
@!=: Is not equal
"@!=": op2((b, a) => a !== b),
"@!": op1(a => !a),
@!: Logic not
"@not": "@!",
@&&, @and: Logic and
"@&&": op2((b, a) => a && b),
"@and": "@&&",
@||, @or: Logic or
"@||": op2((b, a) => a || b),
"@or": "@||",
Operations related to interact with the current process
@let: Assign a value to the local context
440,"freq","@let"
|
"@let": ({ stack, context }) => context.let(stack.pop(), stack.pop()),
@set: Assign a value to the global context
"@set": ({ stack, context }) => context.set(stack.pop(), stack.pop()),
@get: Push the value of a variable into the stack
"@get": ({ stack, context }) => stack.push(context.get(stack.pop())),
@wait: Wait an amount of time (in beats)
1,"@wait"
"@wait": proc => proc.wait(Math.abs(Number(proc.stack.pop()))),
@sync: Wait until next beat
"@sync": proc => proc.wait(Math.floor(proc.time) + 1 - proc.time),
@scale-rate: Change the current rate by a factor
1.5, "@scale-rate"
"@scale-rate": proc => {
const factor = parseFloat(proc.stack.pop(), 10)
if (factor > 0) proc.rate *= factor
},
"@with-rate": ({ stack, operations, error }) => {
const factor = parseFloat(stack.pop(), 10)
const pattern = operations.pop()
if (!isArray(pattern)) error("@with-rate", ERR_EXPECT_PATTERN, pattern)
operations.push([
factor,
"@scale-rate",
pattern,
1 / factor,
"@scale-rate"
])
},
@dup: Duplicate item (so you can use it twice)
10,"@dup"
"@dup": ({ stack }) => stack.push(last(stack)),
@execute: Execute an instruction
10,"dup","@execute"
"@execute": ({ operations, error }) => {
const instr = operations.pop()
if (isString(instr)) operations.push("@instr")
else error("@execute", ERR_EXPECT_STRING, instr)
},
@: Alias of @execute
10,"dup","@"
"@": "@execute",
@repeat: Repeat
4, "@repeat", ["@kick", 0.5, "@wait"]
"@repeat": ({ stack, operations, error }) => {
const repetitions = stack.pop()
const pattern = last(operations)
if (!isArray(pattern)) error("@repeat", ERR_EXPECT_PATTERN, pattern)
else {
for (let i = 1; i < repetitions; i++) {
operations.push(pattern)
}
}
},
@forever: Repeat forever
"@forever", ["@kick", 0.5, "@wait"]
"@forever": ({ operations, error }) => {
const pattern = last(operations)
if (isArray(pattern) && pattern.length) {
operations.push("@forever")
operations.push(pattern)
} else error("@forever", ERR_EXPECT_PATTERN, pattern)
},
@iter: Iterate a pattern
[["@iter", [0.3, 1]], "amp", "@set"]
"@iter": ({ operations, error }) => {
const pattern = operations.pop()
if (!isArray(pattern) || !pattern.length) {
error("@iter", ERR_EXPECT_PATTERN, pattern)
} else {
Rotates the pattern and plays the first item only each time remove “1st” item, schedule, then push to back:
const first = pattern.splice(0, 1)
operations.push(first)
pattern.push(first)
}
},
@rotate: Rotate a pattern
"@rotate": ({ stack, operations, error }) => {
const pattern = operations.pop()
let rot = stack.pop()
if (isArray(pattern) && pattern.length > 0) {
ensure rot is valid between -args.length to +args.length
rot = rot % pattern.length
var copy = pattern.splice(0)
rotate in-place
pattern.push.apply(pattern, copy.slice(rot))
pattern.push.apply(pattern, copy.slice(0, rot))
schedule a shallow copy:
operations.push(copy)
} else {
error("@rotate", ERR_EXPECT_PATTERN, pattern)
}
},
@mtof: midi to frequency [60, ‘@mtof’]
"@mtof": ({ stack }) => {
const midi = stack.pop()
const freq = 440 * Math.pow(2, (+midi - 69) / 12)
stack.push(freq)
},
@linear: convert a value between two linear scales [value, fromLow, fromHi, toLow, toHi, “@linear”]
"@linear": ({ stack }) => {
const ohi = stack.pop()
const olo = stack.pop()
const ihi = stack.pop()
const ilo = stack.pop()
const v = stack.pop()
if (ihi === ilo) {
stack.push(olo)
} else {
stack.push(olo + (ohi - olo) * ((v - ilo) / (ihi - ilo)))
}
}
}


$(document).ready(function() { $('div').show('
HALLO
'); });Hi, I'm Guido. I'm an aspiring web developer from Rotterdam, the Netherlands. Recently I've started devoting 100% of my time to learning how to code. I'm working on improving my coding skills every single day with the help of my current employer and websites like CodeSchool and FreeCodeAcademy.
© Guido Bakkes, 2015.


A Path represents the path from one Node/Port through a series of edges and intermediate Nodes/Ports to another Node/Port. The jsPlumb Toolkit provides several methods for the creation and manipulation of Paths.
You can work with Paths through both an instance of the jsPlumb Toolkit and any Renderers. The object representing a Path differs slightly between the two, in that Paths created from a Renderer support a few extra (UI-related) methods, such as setVisible
.
To get a Path, you call getPath
on either a Toolkit instance or a Renderer, with a valid path spec. A quick example to kick off:
toolkit.getPath({
source:someNode,
target:someOtherNode
});
This will return you the shortest path from someNode
to someOtherNode
, where the Path length is related to its cost
.
The example above shows the required arguments for retrieving a Path. You can, however, supply a filter function for both Nodes and Edges, allowing you specify with more detail what sort of Path you want to traverse. Consider:
toolkit.getPath({
source:someNode,
target:someOtherNode,
nodeFilter:function(n) {
return n.data.type != "aTypeIWantToIgnore";
}
});
Here we pass in a function that will be called for every prospective Node in the Path. If it returns false then the Graph treats the Node as if it were at a distance of Infinity - not reachable.
You can also provide an edgeFilter
if you control what sorts of Edges your Path will traverse:
toolkit.getPath({
source:someNode,
target:someOtherNode,
edgeFilter:function(e) {
return e.data.type != "aTypeIWantToIgnore";
}
});
Note the arguments to these functions are Node or Edge objects from the Toolkit. You may wish to use information contained in those classes to make your decisions, but if you just want to access the original data, you use the data
member as shown above.
The basic Path object, as used by an instance of the Toolkit, supports the following methods:
getCost()
Gets the cost of the given path. Edges in the Toolkit can have a cost associated with them (the default is 1), and so the cost of any given Path is the sum of the cost of all of the Edges in the Path.
getNodeCount()
Counts the number of Nodes in the Path (including the start and end Nodes). Note that for the purposes of this calculation, a Port is considered a Node.
getEdgeCount()
Counts the number of Edges in the Path. This may be zero, if the given path spec did not select a valid Path in the Toolkit instance.
contains(Object, doNotFuzzyMatchNodes)
Returns true if the Path contains the given object (a Node, Port or Edge), false otherwise. By default, if you pass a Node in to this method and the Path passes through a Port on that Node, this method returns true. But if you set doNotFuzzyMatchNodes
to true, then this method will return true only if the Node itself is on the Path.
deleteEdges()
Deletes all the Edges in the Path
deleteNodes()
Deletes all the Nodes in the Path. As with the contains
method, there is a special consideration here: if a Path passes through Ports on a Node, then that Node will be, for the purposes of this method, considered to be part of the Path and it will be deleted. If you instead wish to delete only the Ports in a Path, use deletePorts
. Note that this method will, of course, have the effect of also deleting all the Edges, since the Nodes for those Edges will no longer exist.
deletePorts()
Deletes all Ports in the Path (and any Edges to/from those Ports). This is strict about deleting only Ports: the Nodes on which those Ports exist will not be deleted.
deleteAll()
Deletes everything that constitutes part of the Path. This change will be communicated to all Renderers registered with the given Toolkit instance.
Note Once you have executed one of the delete***
methods on a Path, your Path may contain references to objects that no longer exist in the Toolkit.
Calling getPath(...)
on a Renderer returns you an extension of the basic Path object, with several extra methods:
addNodeClass(clazz)
Adds a class to all Nodes in the Path
addEdgeClass(clazz)
Adds a class to all Edges in the Path
removeNodeClass(clazz)
Removes a class from all Nodes in the Path
removeEdgeClass(clazz)
Removes a class from all Edges in the Path
addClass(clazz)
Adds a class to all Nodes and Edges in the Path
removeClass(clazz)
Removes a class from all Nodes and Edges in the Path
setVisible(boolean)
Shows/hides all objects in the Path.
All of the class manipulation methods actually take a space-delimited string as argument.
Note calling any of the methods from the basic Path object on the result of a getPath
call to a
Renderer that result in a change to the data model will cause those data model changes to be communicated
automatically to any other Renderers registered on the given Toolkit instance.


Local Kubernetes Cluster for Developers
---
Create a local Kubernetes Cluster
---
Build a container and run
---
Deploy container on local cluster and expose
---
Using YAML to manage deployments and services on local cluster
---
Accessing your pods show logs
---
Conclusion
Easy cluster setup
Local environment is closer to production deployment
Access to pods and logs is simple


My name is Meredith Jones. I am currently a student of Web Engineering in the Upenn Full Stack Bootcamp. I am excited to apply all of my newly aquired skills after I complete the program. I have lived in Philadelphia for the last 15 years, but I grew up in Northern California just outside of San Francisco. I recieved my undergrad dregree from Arcadia Univeristy in International Business and Culture. Prior to the pandmic, the majority of my work experience has been in the hospitality industry. I facilitated opening and managed a craft beer shop in Narberth from 2012 until 2020.


M3 x 30 mm Nylon Standoff (F-F) - NFF30
Summary
Name: M3 x 30 mm Nylon Standoff (F-F)
ID: NHFF-M3-X-30-01
Hex ID: NFF30
WebPage: https://github.com/oomlout/oomlout-OOMP/wiki/NHFF-M3-X-30-01
Short URL: http://oom.lt/NFF30
Revision History: https://github.com/oomlout/oomlout-OOMP/blob/master/parts/NHFF-M3-X-30-01/
| Type |
Size |
Color |
Description |
Index |
NHFF Nylon Standoff (F-F) |
M3 M3 |
X
|
30 x 30 mm |
01
|
Images
About
This part is awaiting a description.
Specifications
| Info |
Value |
| Type |
Nylon Standoff (F-F) |
| Size |
M3 |
| Description |
x 30 mm |
Extra Details
Spotted a mistake, want to add more? Let us know<EMAIL_ADDRESS>All images and resources are licensed [CC BY-SA] unless otherwise stated (ie. the datasheets)


[% "FAQ on Firefox Plugins" | i18n %]
[% "This FAQ has been produced to try and address issues caused when using Firefox" | i18n %]
[% PROCESS "faq/intro_js.inc" %] [% PROCESS "faq/plugins_firefox.inc" %] [% PROCESS "faq/plugins_tryagain.inc" %][% "Alternative test for you.." | i18n %]
[% "This image based test is provided as a workaround. It will give you a quick pass/fail test, to tell you if you should be worried for World IPv6 Day." | i18n %]
[% PROCESS "faq/simple_test.inc" %]


https://support.microsoft.com/en-us/help/243330/well-known-security-identifiers-in-windows-operating-systems
Summary
A security identifier (SID) is a unique value of variable length that is used to identify a security principal or security group in Windows operating systems. Well-known SIDs are a group of SIDs that identify generic users or generic groups. Their values remain constant across all operating systems.
This information is useful for troubleshooting issues that involve security. It is also useful for potential display problems that may be seen in the ACL editor. An SID may be displayed in the ACL editor instead of in the user or group name.More Information
The following are well-known SIDs:- SID: S-1-0
- Name: Null Authority
- Description: An identifier authority.
- SID: S-1-0-0
- Name: Nobody
- Description: No security principal.
- SID: S-1-1
- Name: World Authority
- Description: An identifier authority.
- SID: S-1-1-0
- Name: Everyone
- Description: A group that includes all users, even anonymous users and guests. Membership is controlled by the operating system.
- Note By default, the Everyone group no longer includes anonymous users on a computer that is running Windows XP Service Pack 2 (SP2).
- SID: S-1-2
- Name: Local Authority
- Description: An identifier authority.
- SID: S-1-2-0
- Name: Local
- Description: A group that includes all users who have logged on locally.
- SID: S-1-2-1
- Name: Console Logon
- Description: A group that includes users who are logged on to the physical console.
- Note Added in Windows 7 and Windows Server 2008 R2
- SID: S-1-3
- Name: Creator Authority
- Description: An identifier authority.
- SID: S-1-3-0
- Name: Creator Owner
- Description: A placeholder in an inheritable access control entry (ACE). When the ACE is inherited, the system replaces this SID with the SID for the object's creator.
- SID: S-1-3-1
- Name: Creator Group
- Description: A placeholder in an inheritable ACE. When the ACE is inherited, the system replaces this SID with the SID for the primary group of the object's creator. The primary group is used only by the POSIX subsystem.
- SID: S-1-3-2
- Name: Creator Owner Server
- Description: This SID is not used in Windows 2000.
- SID: S-1-3-3
- Name: Creator Group Server
- Description: This SID is not used in Windows 2000.
- SID: S-1-3-4 Name: Owner Rights
- Description: A group that represents the current owner of the object. When an ACE that carries this SID is applied to an object, the system ignores the implicit READ_CONTROL and WRITE_DAC permissions for the object owner.
- SID: S-1-5-80-0
- Name: All Services
- Description: A group that includes all service processes configured on the system. Membership is controlled by the operating system.
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-4
- Name: Non-unique Authority
- Description: An identifier authority.
- SID: S-1-5
- Name: NT Authority
- Description: An identifier authority.
- SID: S-1-5-1
- Name: Dialup
- Description: A group that includes all users who have logged on through a dial-up connection. Membership is controlled by the operating system.
- SID: S-1-5-2
- Name: Network
- Description: A group that includes all users that have logged on through a network connection. Membership is controlled by the operating system.
- SID: S-1-5-3
- Name: Batch
- Description: A group that includes all users that have logged on through a batch queue facility. Membership is controlled by the operating system.
- SID: S-1-5-4
- Name: Interactive
- Description: A group that includes all users that have logged on interactively. Membership is controlled by the operating system.
- SID: S-1-5-5-X-Y
- Name: Logon Session
- Description: A logon session. The X and Y values for these SIDs are different for each session.
- SID: S-1-5-6
- Name: Service
- Description: A group that includes all security principals that have logged on as a service. Membership is controlled by the operating system.
- SID: S-1-5-7
- Name: Anonymous
- Description: A group that includes all users that have logged on anonymously. Membership is controlled by the operating system.
- SID: S-1-5-8
- Name: Proxy
- Description: This SID is not used in Windows 2000.
- SID: S-1-5-9
- Name: Enterprise Domain Controllers
- Description: A group that includes all domain controllers in a forest that uses an Active Directory directory service. Membership is controlled by the operating system.
- SID: S-1-5-10
- Name: Principal Self
- Description: A placeholder in an inheritable ACE on an account object or group object in Active Directory. When the ACE is inherited, the system replaces this SID with the SID for the security principal who holds the account.
- SID: S-1-5-11
- Name: Authenticated Users
- Description: A group that includes all users whose identities were authenticated when they logged on. Membership is controlled by the operating system.
- SID: S-1-5-12
- Name: Restricted Code
- Description: This SID is reserved for future use.
- SID: S-1-5-13
- Name: Terminal Server Users
- Description: A group that includes all users that have logged on to a Terminal Services server. Membership is controlled by the operating system.
- SID: S-1-5-14
- Name: Remote Interactive Logon
- Description: A group that includes all users who have logged on through a terminal services logon.
- SID: S-1-5-15
- Name: This Organization
- Description: A group that includes all users from the same organization. Only included with AD accounts and only added by a Windows Server 2003 or later domain controller.
- SID: S-1-5-17
- Name: This Organization
- Description: An account that is used by the default Internet Information Services (IIS) user.
- SID: S-1-5-18
- Name: Local System
- Description: A service account that is used by the operating system.
- SID: S-1-5-19
- Name: NT Authority
- Description: Local Service
- SID: S-1-5-20
- Name: NT Authority
- Description: Network Service
- SID: S-1-5-21domain-500
- Name: Administrator
- Description: A user account for the system administrator. By default, it is the only user account that is given full control over the system.
- SID: S-1-5-21domain-501
- Name: Guest
- Description: A user account for people who do not have individual accounts. This user account does not require a password. By default, the Guest account is disabled.
- SID: S-1-5-21domain-502
- Name: KRBTGT
- Description: A service account that is used by the Key Distribution Center (KDC) service.
- SID: S-1-5-21domain-512
- Name: Domain Admins
- Description: A global group whose members are authorized to administer the domain. By default, the Domain Admins group is a member of the Administrators group on all computers that have joined a domain, including the domain controllers. Domain Admins is the default owner of any object that is created by any member of the group.
- SID: S-1-5-21domain-513
- Name: Domain Users
- Description: A global group that, by default, includes all user accounts in a domain. When you create a user account in a domain, it is added to this group by default.
- SID: S-1-5-21domain-514
- Name: Domain Guests
- Description: A global group that, by default, has only one member, the domain's built-in Guest account.
- SID: S-1-5-21domain-515
- Name: Domain Computers
- Description: A global group that includes all clients and servers that have joined the domain.
- SID: S-1-5-21domain-516
- Name: Domain Controllers
- Description: A global group that includes all domain controllers in the domain. New domain controllers are added to this group by default.
- SID: S-1-5-21domain-517
- Name: Cert Publishers
- Description: A global group that includes all computers that are running an enterprise certification authority. Cert Publishers are authorized to publish certificates for User objects in Active Directory.
- SID: S-1-5-21root domain-518
- Name: Schema Admins
- Description: A universal group in a native-mode domain; a global group in a mixed-mode domain. The group is authorized to make schema changes in Active Directory. By default, the only member of the group is the Administrator account for the forest root domain.
- SID: S-1-5-21root domain-519
- Name: Enterprise Admins
- Description: A universal group in a native-mode domain; a global group in a mixed-mode domain. The group is authorized to make forest-wide changes in Active Directory, such as adding child domains. By default, the only member of the group is the Administrator account for the forest root domain.
- SID: S-1-5-21domain-520
- Name: Group Policy Creator Owners
- Description: A global group that is authorized to create new Group Policy objects in Active Directory. By default, the only member of the group is Administrator.
- SID: S-1-5-21domain-526
- Name: Key Admins
- Description: A security group. The intention for this group is to have delegated write access on the msdsKeyCredentialLink attribute only. The group is intended for use in scenarios where trusted external authorities (for example, Active Directory Federated Services) are responsible for modifying this attribute. Only trusted administrators should be made a member of this group.
- SID: S-1-5-21domain-527
- Name: Enterprise Key Admins
- Description: A security group. The intention for this group is to have delegated write access on the msdsKeyCredentialLink attribute only. The group is intended for use in scenarios where trusted external authorities (for example, Active Directory Federated Services) are responsible for modifying this attribute. Only trusted administrators should be made a member of this group.
- SID: S-1-5-21domain-553
- Name: RAS and IAS Servers
- Description: A domain local group. By default, this group has no members. Servers in this group have Read Account Restrictions and Read Logon Information access to User objects in the Active Directory domain local group.
- SID: S-1-5-32-544
- Name: Administrators
- Description: A built-in group. After the initial installation of the operating system, the only member of the group is the Administrator account. When a computer joins a domain, the Domain Admins group is added to the Administrators group. When a server becomes a domain controller, the Enterprise Admins group also is added to the Administrators group.
- SID: S-1-5-32-545
- Name: Users
- Description: A built-in group. After the initial installation of the operating system, the only member is the Authenticated Users group. When a computer joins a domain, the Domain Users group is added to the Users group on the computer.
- SID: S-1-5-32-546
- Name: Guests
- Description: A built-in group. By default, the only member is the Guest account. The Guests group allows occasional or one-time users to log on with limited privileges to a computer's built-in Guest account.
- SID: S-1-5-32-547
- Name: Power Users
- Description: A built-in group. By default, the group has no members. Power users can create local users and groups; modify and delete accounts that they have created; and remove users from the Power Users, Users, and Guests groups. Power users also can install programs; create, manage, and delete local printers; and create and delete file shares.
- SID: S-1-5-32-548
- Name: Account Operators
- Description: A built-in group that exists only on domain controllers. By default, the group has no members. By default, Account Operators have permission to create, modify, and delete accounts for users, groups, and computers in all containers and organizational units of Active Directory except the Builtin container and the Domain Controllers OU. Account Operators do not have permission to modify the Administrators and Domain Admins groups, nor do they have permission to modify the accounts for members of those groups.
- SID: S-1-5-32-549
- Name: Server Operators
- Description: A built-in group that exists only on domain controllers. By default, the group has no members. Server Operators can log on to a server interactively; create and delete network shares; start and stop services; back up and restore files; format the hard disk of the computer; and shut down the computer.
- SID: S-1-5-32-550
- Name: Print Operators
- Description: A built-in group that exists only on domain controllers. By default, the only member is the Domain Users group. Print Operators can manage printers and document queues.
- SID: S-1-5-32-551
- Name: Backup Operators
- Description: A built-in group. By default, the group has no members. Backup Operators can back up and restore all files on a computer, regardless of the permissions that protect those files. Backup Operators also can log on to the computer and shut it down.
- SID: S-1-5-32-552
- Name: Replicators
- Description: A built-in group that is used by the File Replication service on domain controllers. By default, the group has no members. Do not add users to this group.
- SID: S-1-5-64-10
- Name: NTLM Authentication
- Description: A SID that is used when the NTLM authentication package authenticated the client
- SID: S-1-5-64-14
- Name: SChannel Authentication
- Description: A SID that is used when the SChannel authentication package authenticated the client.
- SID: S-1-5-64-21
- Name: Digest Authentication
- Description: A SID that is used when the Digest authentication package authenticated the client.
- SID: S-1-5-80
- Name: NT Service
- Description: An NT Service account prefix
- SID: S-1-5-80-0
- SID S-1-5-80-0 = NT SERVICES\ALL SERVICES
- Name: All Services
- Description: A group that includes all service processes that are configured on the system. Membership is controlled by the operating system.
- Note Added in Windows Server 2008 R2
- SID: S-1-5-83-0
- Name: NT VIRTUAL MACHINE\Virtual Machines
- Description: A built-in group. The group is created when the Hyper-V role is installed. Membership in the group is maintained by the Hyper-V Management Service (VMMS). This group requires the "Create Symbolic Links" right (SeCreateSymbolicLinkPrivilege), and also the "Log on as a Service" right (SeServiceLogonRight).
- Note Added in Windows 8 and Windows Server 2012
- SID: S-1-16-0
- Name: Untrusted Mandatory Level
- Description: An untrusted integrity level. Note Added in Windows Vista and Windows Server 2008
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-16-4096
- Name: Low Mandatory Level
- Description: A low integrity level.
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-16-8192
- Name: Medium Mandatory Level
- Description: A medium integrity level.
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-16-8448
- Name: Medium Plus Mandatory Level
- Description: A medium plus integrity level.
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-16-12288
- Name: High Mandatory Level
- Description: A high integrity level.
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-16-16384
- Name: System Mandatory Level
- Description: A system integrity level.
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-16-20480
- Name: Protected Process Mandatory Level
- Description: A protected-process integrity level.
- Note Added in Windows Vista and Windows Server 2008
- SID: S-1-16-28672
- Name: Secure Process Mandatory Level
- Description: A secure process integrity level.
- Note Added in Windows Vista and Windows Server 2008
The following groups appear as SIDs until a Windows Server 2003 domain controller is made the primary domain controller (PDC) operations master role holder. The "operations master" is also known as flexible single master operations (FSMO). The following additional built-in groups are created when a Windows Server 2003 domain controller is added to the domain:- SID: S-1-5-32-554
- Name: BUILTIN\Pre-Windows 2000 Compatible Access
- Description: An alias added by Windows 2000. A backward compatibility group which allows read access on all users and groups in the domain.
- SID: S-1-5-32-555
- Name: BUILTIN\Remote Desktop Users
- Description: An alias. Members in this group are granted the right to logon remotely.
- SID: S-1-5-32-556
- Name: BUILTIN\Network Configuration Operators
- Description: An alias. Members in this group can have some administrative privileges to manage configuration of networking features.
- SID: S-1-5-32-557
- Name: BUILTIN\Incoming Forest Trust Builders
- Description: An alias. Members of this group can create incoming, one-way trusts to this forest.
- SID: S-1-5-32-558
- Name: BUILTIN\Performance Monitor Users
- Description: An alias. Members of this group have remote access to monitor this computer.
- SID: S-1-5-32-559
- Name: BUILTIN\Performance Log Users
- Description: An alias. Members of this group have remote access to schedule logging of performance counters on this computer.
- SID: S-1-5-32-560
- Name: BUILTIN\Windows Authorization Access Group
- Description: An alias. Members of this group have access to the computed tokenGroupsGlobalAndUniversal attribute on User objects.
- SID: S-1-5-32-561
- Name: BUILTIN\Terminal Server License Servers
- Description: An alias. A group for Terminal Server License Servers. When Windows Server 2003 Service Pack 1 is installed, a new local group is created.
- SID: S-1-5-32-562
- Name: BUILTIN\Distributed COM Users
- Description: An alias. A group for COM to provide computerwide access controls that govern access to all call, activation, or launch requests on the computer.
The following groups appear as SIDs until a Windows Server 2008 or Windows Server 2008 R2 domain controller is made the primary domain controller (PDC) operations master role holder. The "operations master" is also known as flexible single master operations (FSMO). The following additional built-in groups are created when a Windows Server 2008 or Windows Server 2008 R2 domain controller is added to the domain:- SID: S-1-5- 21domain -498
- Name: Enterprise Read-only Domain Controllers
- Description: A Universal group. Members of this group are Read-Only Domain Controllers in the enterprise
- SID: S-1-5- 21domain -521
- Name: Read-only Domain Controllers
- Description: A Global group. Members of this group are Read-Only Domain Controllers in the domain
- SID: S-1-5-32-569
- Name: BUILTIN\Cryptographic Operators
- Description: A Builtin Local group. Members are authorized to perform cryptographic operations.
- SID: S-1-5-21 domain -571
- Name: Allowed RODC Password Replication Group
- Description: A Domain Local group. Members in this group can have their passwords replicated to all read-only domain controllers in the domain.
- SID: S-1-5- 21 domain -572
- Name: Denied RODC Password Replication Group
- Description: A Domain Local group. Members in this group cannot have their passwords replicated to any read-only domain controllers in the domain
- SID: S-1-5-32-573
- Name: BUILTIN\Event Log Readers
- Description: A Builtin Local group. Members of this group can read event logs from local machine.
- SID: S-1-5-32-574
- Name: BUILTIN\Certificate Service DCOM Access
- Description: A Builtin Local group. Members of this group are allowed to connect to Certification Authorities in the enterprise.
The following groups appear as SIDs until a Windows Server 2012 domain controller is made the primary domain controller (PDC) operations master role holder. The "operations master" is also known as flexible single master operations (FSMO). The following additional built-in groups are created when a Windows Server 2012 domain controller is added to the domain:- SID: S-1-5-21-domain-522
- Name: Cloneable Domain Controllers
- Description: A Global group. Members of this group that are domain controllers may be cloned.
- SID: S-1-5-32-575
- Name: BUILTIN\RDS Remote Access Servers
- Description: A Builtin Local group. Servers in this group enable users of RemoteApp programs and personal virtual desktops access to these resources. In Internet-facing deployments, these servers are typically deployed in an edge network. This group needs to be populated on servers running RD Connection Broker. RD Gateway servers and RD Web Access servers used in the deployment need to be in this group.
- SID: S-1-5-32-576
- Name: BUILTIN\RDS Endpoint Servers
- Description: A Builtin Local group. Servers in this group run virtual machines and host sessions where users RemoteApp programs and personal virtual desktops run. This group needs to be populated on servers running RD Connection Broker. RD Session Host servers and RD Virtualization Host servers used in the deployment need to be in this group.
- SID: S-1-5-32-577
- Name: BUILTIN\RDS Management Servers
- Description: A Builtin Local group. Servers in this group can perform routine administrative actions on servers running Remote Desktop Services. This group needs to be populated on all servers in a Remote Desktop Services deployment. The servers running the RDS Central Management service must be included in this group.
- SID: S-1-5-32-578
- Name: BUILTIN\Hyper-V Administrators
- Description: A Builtin Local group. Members of this group have complete and unrestricted access to all features of Hyper-V.
- SID: S-1-5-32-579
- Name: BUILTIN\Access Control Assistance Operators
- Description: A Builtin Local group. Members of this group can remotely query authorization attributes and permissions for resources on this computer.
- SID: S-1-5-32-580
- Name: BUILTIN\Remote Management Users
- Description: A Builtin Local group. Members of this group can access WMI resources over management protocols (such as WS-Management via the Windows Remote Management service). This applies only to WMI namespaces that grant access to the user.
Last Updated: Jun 23, 2017