Webshims Lib is a modular capability-based polyfill-loading library, which focuses on accurate implementations of stable HTML5 features, so that developers can write modern, interoperable and robust code in all browsers. It is built on top of jQuery and Modernizr.
Main concepts
- Capability based loading: the more features a browser supports natively, the more lightweight webshims will be
- Modular feature implementation: Only load features that you need for your application.
- Future-proof feature detection: We try to feature detect everything instead of browser sniffing to be more future proof
- Almost pure native and accurate APIs Helps you to learn HTML5 (Markup-/DOM/JS-APIs) and to build useful abstractions and extensions on top of the standard. Documentation is the specification (e.g. HTML5 W3C Specification)
- stable and reliable polyfills for current and future x-browser landscape: webshims lib's polyfills are cross-browser tested and work with incapable, buggy, partial and of course full capable HTML5 implementations.
What makes webshims lib different?
Did you ever try to dynamically set or get the placeholder or the value attribute of a text input with one of the other placeholder shims? With many of them it doesn't properly work. Webshims strives to provide a uniform and standards-compliant API in every environment.
The following text input uses the html5 placeholder attribute:
If you're viewing this page in a browser that doesn't support placeholder, Webshims has added this functionality via Javascript, and in a way that preserves your ability to work with the element's properties dynamically:
$("#placeholder").attr("placeholder", "");
Being able to change the placeholder of an input element dynamically isn't a huge deal, but it shows how webshims lib works. With few exceptions, you won't be able to tell the difference between a shim and a native implementation. In some cases, the shim will even be more standards compliant than some browsers' native implementations.
The placeholder polyfill also works with getting and setting the value property (many other placeholder polyfills don't support this properly):
$("#placeholder").prop('value')
$("#placeholder").val()
$("#placeholder").prop('value', 'new value')
$("#placeholder").val('new value')
tested Browser Support
- IE7+
- Firefox 3.6+
- Safari 5.1+
- Safari for iOS 5+
- Chrome 24.0+
- Opera 12.1+
Features / Demos
How to
Easy & simple Quick install
<!-- dependencies: jQuery + Modernizr with yepnope -->
<script src="js/jquery-1.9.1.js"></script>
<script src="js/modernizr-yepnope-custom.js"></script>
<!-- reference the base script -->
<script src="js-webshim/minified/polyfiller.js"></script>
<script>
//implement all unsupported features || call polyfill before DOM-Ready to implement everything as soon and as fast as possible
$.webshims.polyfill();
//or load only specific features you need
//$.webshims.polyfill('forms json-storage');
$(function(){
//use all implemented API-features on DOM-ready
});
</script>
Note: Webshims do not need all Modernizr tests to work. Here you find all Modernizr detections, which are used by webshims.
Embedding and configuring the script
- Take the 'js-webshim' folder and add it to your project. (You will find a minified and a dev folder there.)
- Include the polyfiller.js into your HTML page. You can concatenate this file with your other js and rename. Don't forget to also include jQuery, Modernizr (including Modernizr.load).
- call the polyfill method
<script src="js/jquery-1.9.1.js"></script>
<script src="js/modernizr-yepnope-custom.js"></script>
<script src="js-webshim/minified/polyfiller.js"></script>
<script>
//load and implement all unsupported features || call polyfill before DOM-Ready to implement everything as soon and as fast as possible
$.webshims.polyfill();
</script>
The polyfill method can also take a whitespace-separated list of several features and should be called as soon as possible (before DOM ready).
//load and implement json-storage and geolocation features, if they aren't supported
$.webshims.polyfill('json-storage geolocation');
List of features
json-storage
es5
geolocation
canvas
forms
forms-ext
mediaelement
track
filereader
details
If you have any trouble setting up Webshims lib, set $.webshims.debug
to true and open your console:
<script>
$.webshims.debug = true;
$.webshims.polyfill();
</script>
If you dont want any log messsages, simply set $.webshims.debug
explicitly to false
.
Custom Modernizr build
Webshims lib does not need every Modernizr test and supports creating a custom Modernizr build. (Webshims lib uses requireJS or sssl as a script loader, if this is included, if not it uses Modernizr.load/yepnope.)
changing Options path to shims folder
Shims folder is computed automatically. If the name of polyfiller.js is changed and the polyfill-script is loaded async, this computation can be wrong and you have to set the folder manually. This generated path can be changed by changing the basePath
configuration with the setOptions
method.
$.webshims.setOptions("basePath", "/yourFolderTo/shims/");
//or:
$.webshims.setOptions({
basePath: "/yourFolderTo/shims/"
});
Fire when ready
Not every feature is ready immediately in all browsers; some shims might take time to load before you can use them. You can use one of jQuery's ready
methods to delay working with elements until the DOM and any necessary shims are ready.
$(function(){
//work with DOM + all implemented features
});
$(document).ready(function(){
//work with DOM + all features
});
If you want to use a feature as soon as possible or you have set the waitReady
option to false
, you can use $.webshims.ready
and pass the feature name(s) and a callback function:
$.webshims.ready('geolocation json-storage', function(){
//work with geolocation, JSON and localStorage
});
Note that this callback function may be called before the DOM is ready. If you want to use a feature after DOM-Ready, simply pass the string 'DOM':
$.webshims.ready('DOM canvas', function(){
//work with canvas in the document
});
Setting options
Webshims has some general and some feature specific options which can be configured with the $.webshims.setOptions
method.
setOptions
should always be called before the polyfill
method.
The available general options are the following:
- extendNative (default: true) (will be set to false with next version): Webshims lib will automatically extend DOM-Objects with polyfilled methods and will additionally generate a jQuery plugin with this method name. If extendNative is set to false, webshims lib won't touch any DOM-Objects and will only implement jQuery plugins. Setting this option to false, might be also good for DOM performance (see also).
- basePath (default: "automatially computed path to the shims folder"): If polyfiller.js was renamed and is loaded dynamically, the basePath should be changed manually.
- waitReady (default: true): If this option is true, jQuery's ready-event will be delayed until all needed features are ready to use. This option should be set to false, if webshims lib polyfiller.js is loaded async (see also Loading webshims async in the loading documentation) or from bottom of the body element. This option can also be set to false, if a website is using only HTML5 markup APIs (pure HTML or $.attr) and do not use any DOM-/JS-APIs on DOM-ready. If this feature is set to false, which might be good against FOUCs, scripted access to polyfilled APIs have to be added inside of a
$.webshims.ready
callback. - useImportantStyles (default: false): If this option is true, Webshims basic stylesheet won't use any !important styles.
- disableShivMethods (default: true): Automatically disables the shivMethods option of html5shiv.
$.webshims.setOptions("extendNative", false);
setOptions
can also take a single options parameter:
$.webshims.setOptions({
extendNative: false
});
Feature specific options are nested options with the featurename as their key.
$.webshims.setOptions({
//configure generally option
extendNative: false,
//configure canvas-shim
canvas: {
type: "flash" // use flashcanvas instead of excanvas as polyfill
},
//configure forms-shim
forms: {
customMessages: true // implement customValidationMessages
}
});
The polyfill-options can also be changed by using declarative markup, using a data-polyfill-cfg attribute with a valid JSON string on a script-element:
<script src="some.js" data-polyfill='{
"basePath": "pathToYour/shims-folder/",
"canvas": {
"type": "flash"
}
}'>
</script>
Minor Abstractions to DOM attributes, DOM methods and DOM events
Due to the fact that we cannot extend accessors of elements in all browsers, we always use jQuery as an extension-wrapper.
-
Accessing DOM properties/attribute IDLs: if the feature allows accessing a specific attribute or property, always use jQuery's built-in
$.prop
(in case of IDL attributes/properties) or$.attr
/$.removeAttr
(in case of content attributes) method:// instead of accessing a property directly (e.g. this.validity), use $.fn.prop $(this).prop('validity'); // or: //$.prop(this, 'validity'); //setting a property $('video').prop('currentTime', 200); // or: //$.prop(videoElement, 'currentTime', 200);
-
calling a DOM method: While DOM properties have to be accessed through jQuery's
$.prop/$.attr
methods, DOM methods have to be accesed using $.prop and executed in the context of the DOMK element.// "this" refers to a DOM element, not a jQuery object var fn = $.prop(this, 'checkValidity'); fn.apply(this);
To make this more easier Webshims lib also generates a jQuery plugin which wraps the featured method, so you can use jQuery too:
$(this).checkValidity(); $(this).callProp('checkValidity'); // $(this).callProp('play');
If you pass a list of nodes and the method doesn't return anything, the method will be called on each element in this list, otherwise it will be called on the first element.
In case a developer wants to make method calling "feel more native", ithe general option
extendNative
can be set totrue
.$.webshims.setOptions("extendNative", true); $.webshims.polyfill('forms'); //... this.checkValidity() //does now work cross-browser. $(this).checkValidity(); or $(this).callProp('checkValidity'); can still be used
-
binding to events: Always use jQuery's
bind
method to register your event handlers.addEventListener
or inline event handler won't work in polyfilled browsers. Most events in the HTML5 specification are so-called simple events. Simple events do not bubble. Due to the fact that developers really like event delegation and jQuery cannot distinguish between the event phases (capturing/propagation), we use event capturing in the native implementation and$.fn.trigger
in the shim.This means that some HTML5 events go down the DOM tree in capable browsers and go up the tree in polyfilled browsers. This can create differences if you are calling
event.stopPropagation();
orreturn false;
in your event handler. If you only want to prevent the default, don't usereturn false;
, useevent.preventDefault();
instead. -
manipulation methods/dynamically adding HTML5 content: To insert new HTML5 content dynamically, use
.htmlPolyfill()
,.appendPolyfill()
,.prependPolyfill()
,.afterPolyfill()
,.beforePolyfill()
and.replaceWithPolyfill()
://three different examples $('form').appendPolyfill('<fieldset><input type="date" /></fieldset>'); $('#canvas-box').htmlPolyfill('<canvas></canvas>'); $('datalist#list select').prependPolyfill('<option value="new suggestion item" />');
See also dynamic HTML5 description.
-
no shadowdom: Webshims lib sometimes has to add additional DOM elements to mimic the UI of HTML5 elements. This can sometimes create differences, between polyfilled and non polyfilled browsers. Webshims lib gives you a method called 'getShadowElement' to access the shadowelement from the native element and a method called 'getNativeElement' to access the native element from the shadowelement. If the element has no shadowelement the element itself is returned.
//animate the width of all date - inputs to a width of 300 $('input[type="date"]').getShadowElement().animate({width: 300});
re-rendering shadowelements: On dynamic websites shadowelements dimensions and/or positions sometimes need to be updated, this can be achieved by triggering the
updateshadowdom
.$.event.trigger('updateshadowdom');
Note: The
updateshadowdom
event is automatically (but 'lazily') triggered on window.resize/emchange events.
Loading, Performance, FOUCs
Making webshims lib more lightweight (call polyfill conditionally)
Webshims lib can be considered as very lightweight polyfill libary. Feature implementations are only loaded in browsers, which do not support those features without any blocking behavior.
The grouping of features in webshims lib however is a balancing act. For grouping features, we take the following aspects into account: filesize vs. HTTP-request (minimize requests vs. parallelise requests), relation between features (JSON has nothing to do with input[placeholder], but with localStorage) and the current featureset of modern browsers (current modern browsers shouldn't load too much).
In some cases those grouping decisions - made by webshims lib - do not really fit the needs of a project. An example: If a project only need the input[placeholder] and input[autofocus] features, the forms
feature has to be used. But forms
does not only implement those needed features, but also constraint validation and some other features like formtarget.
This would not hurt a browser, which hasn't implemented anything of this (Due to our minimize requests and non blocking approach, the additional filesize isn't really significant). But it hurts browsers, which have implemented those features, but haven't implemented the other features (For example: Safari 5 has no validation UI. Opera 11.5 has a buggy validation API).
To make webshims lib really lightweight in those cases, the polyfill
method should be called conditionally:
//only polyfill forms, if placeholder or autofocus are not supported
if(!Modernizr.input.placeholder || !Modernizr.input.autofocus){
$.webshims.polyfill('forms');
}
And in case of adding multiple conditionally features:
//always polyfill mediaelement -> mp4, flv, youtube in all browsers
var polyfillFeatures = ['mediaelement'];
//only polyfill forms, if placeholder or autofocus are not supported
if(!Modernizr.input.placeholder || !Modernizr.input.autofocus){
polyfillFeatures.push('forms');
}
//Start polyfilling
$.webshims.polyfill(polyfillFeatures);
Customize Webshims lib's polyfiller.js
While webshims lib comes with a lot of files, the polyfiller.js file is the only file, which has to be embeded directly in the page. The following tool allows you to customize and minimize the polyfiller.js file. (Simply overwrite the polyfiller.js with your customized version. All other files from the download package should stay.):
Loading webshims async
If webshims lib is loaded async, there are some configurations which have to be changed manually:
- waitReady: should be changed to false. Note: you can not rely on jQuery's DOM-Ready event anymore.
- basePath: should be set manually
A typical configuration and usage for webshims lib loading async (using yepnope) would look like this:
<script src="modernizr-yepnope.js"></script>
<script>
Modernizr.load([
{
load: '//ajax.googleapis.com/ajax/libs/jquery/1.6.3/jquery.js',
complete: function () {
if ( !window.jQuery ) {
Modernizr.load('/js/libs/jquery-1.6.2.min.js');
}
}
},
{
// This will wait for the fallback to load and execute
load: '/js/libs/combined-package-with-polyfiller.js',
complete: function () {
//The following code can be also inside of your combined-package-with-polyfiller.js file package
if ( jQuery.webshims ) {
//change webshims options
jQuery.webshims.setOptions({
waitReady: false,
basePath: "/js/libs/shims/"
});
//start polyfilling
jQuery.webshims.polyfill('forms canvas');
//wait for the normal ready event and...
jQuery(function($){
//wait until all requested features are implemented
$.wehshims.ready('canvas forms', function(){
//use polyfilled features
var context = $('#myCanvas').getContext("2d");
});
});
}
}
}
]);
</script>
</head>
Webshims polyfiller main file also registers as a "polyfiller" named AMD module. A typical configuration for loading webshims and jQuery async, using requireJS, would look like this:
<script src="require.js"></script>
<script src="modernizr.custom.js"></script>
<script>
//requireJS config
//...
require( ["jquery", "polyfiller"], function(e){
//change webshims options
jQuery.webshims.setOptions({
waitReady: false,
basePath: "/js/libs/shims/"
});
//start polyfilling
jQuery.webshims.polyfill('forms canvas');
//wait for the normal ready event and...
jQuery(function($){
//wait until all requested features are implemented
$.wehshims.ready('canvas forms', function(){
//use polyfilled features
var context = $('#myCanvas').getContext("2d");
});
});
});
</script>
</head>
Dealing with FOUCs
Webshims lib uses a script loader and loading scripts dynamically always have the potential to create so called Flash of unstyled contents or Flash of unbehaviored contents.
There are a lot ways to deal with FOUCs/FOUBCs. The most easiest way to remove FOUCs caused by webshims lib is:
- Put your JS into your head and call $.webshims.polyfill() immediately (before DOM-Ready)
- Put the following CSS in your Stylesheet:
/* The class loading-polyfills is set after you have called polyfill and will be removed as soon as all polyfills are loaded and implemented */ html.loading-polyfills body { visibility: hidden; } /* If polyfilling takes longer as 600ms, an additional class called 'long-loading-polyfill' will be set It's good practice to show the user that something is going on in this case */ html.long-loading-polyfills { background-image: url(polyfill-loader.gif); background-position: center 240px; background-repeat: no-repeat; }
Why you should put your webshims inside of your documents head
There is a lot of misunderstanding about the yslow rule "Put your JavaScript at the bottom". Put your JavaScript at the bottom does not decrease total page load time. The effect is psychologic. The user sooner sees how the page is loading, because JS blocks the UI rendering.
This also means that a FOUC is not a side effect of "Put your JavaScript at the bottom". It is the intended effect of this technique.
Using a script loader (and webshims lib uses a script loader) has a very similiar effect, because dynamically added scripts won't block the UI anymore. Combining both techniques will increase FOUCs.
If you use a script loader and put your JS at top you have done everything right about performance. Some versions of yslow recognize that you have used this technique and won't subtract points for this rule ("Put your JavaScript at the bottom"). The nice thing about script loaders is, that loading JS-files dynamically will additionally decrease page load time, because all browsers can parallelize script loading.
How to write a new feature implementation?
A Pollyfill is always split into at least two parts. First the test and loader definition, and then the implementation.
Assume there is a new method magicMethod
on the window object that we want to polyfill if the browser doesn't provide it. An implementation would look like this:
$.webshims.addPolyfill('magicMethod', {
test: function(){
return ('magicMethod' in window);
}
});
// loads magicMethod.js from shim-folder if test returns false
Create a file called magicMethod with your polyfill code and place it in the shim folder:
window.magicMethod = function(){
//your polyfill implementation
};
If your implementation has dependencies on other polyfills/modules, you can add a dependencies property to make sure they're loaded too:
$.webshims.addPolyfill('magicMethod', {
test: function(){
return ('magicMethod' in window);
},
d: ['es5', 'json-storage'] // d = dependencies
});
// load magicMethod.js and its dependencies if test returns false
If your shim has dependencies, you have to register your implementation code with $.webshims.register
:
jQuery.webshims.register('magicMethod', function($, webshims, window, document, undefined, options){
//now you can use es5-feature and json-storage feature
window.magicMethod = function(){
//your polyfill implementation
};
});
In case of a DOM extension, webshims lib comes with some useful extension-methods.
$.webshims.addPolyfill('mediaelement', {
test: function(){
return ('canPlayType' in document.createElement('video'));
},
d: ['dom-support'],
methodNames: ['play'] //pause, load
});
// load mediaelement.js and DOM extension features from shim folder
// if test returns false and always create a jQuery plugin called play,
// which tries to invoke native or polyfilled play
// listen to 'play' events in the capturing phase
// can use event delegation with jQuery's bind method
$.webshims.capturingEvents(['play']);
Now put a mediaelement.js inside of your shim folder and start implementing some features. The dom-support
feature of Webshims lib comes with some very useful implementation helpers. Here are two of them:
$.webshims.defineNodeNamesProperty
(nodeNames, property, descriptor)$.webshims.defineNodeNamesBooleanProperty
(nodeNames, property, descriptor)
//wait till the DOM-Extension feature is loaded
jQuery.webshims.register('mediaelement', function($, webshims, window, document, undefined, options){
//note: webshims refers to jQuery.webshims in this function
//Implements a new IDL property on audio, video called currentTime
webshims.defineNodeNamesProperty('audio, video', 'currentTime', {
prop: {
get: function(){
//your getter implementation ("this" refers to the element)
},
set: function(value){
//your setter implementation ("this" refers to the element)
}
}
});
//Implements a new constant property called HAVE_CURRENT_DATA on audio, video
webshims.defineNodenamesProperty('audio, video', 'HAVE_CURRENT_DATA', {
prop: {
value: 2
}
});
//Implements a new method called play on audio, video
webshims.defineNodeNamesProperty('audio, video', 'play', {
prop: {
value: function(){
//your play method implementation
//this refers to the element
}
}
});
//Implements a new boolean IDL property called controls on audio, video
//which is reflected by a content attribute
webshims.defineNodeNamesBooleanProperty('audio, video', 'controls', {
//set works more like an onSet:
//you don't have to set the value anymore on the DOM node, only handle true/false values
set: function(value){
if(value){
//show controls for elem
} else {
//hide controls for elem
}
},
initAttr: true
});
});
Webshims polyfilling philosophy
Abstractions vs. Polyfills
A polyfill is a shim that mimics/replicates a future/standarized API using legacy techniques to older browsers. A "shim-abstraction" is a code that uses modern and legacy techniques to create a new unstandardized API.
An abstraction can have several advantages over a pure polyfill. One of those advantages is a more clean and more easy-to-use API. Webshims Lib has decided to create/use polyfills (with some extensions on top of the standard, not instead!). This decision has several reasons.
Make learning new web technologies easy: It's an easy question: Do you want to learn proprietary or standardized code.
Make interoperability easy: Although Webshims Lib technique to create DOM-Setters and DOM-Getters is an abstraction (always use $.prop/$.attr to get/set DOM-Attributes). This abstraction is compatible to HTML5-browsers and makes writing interoperable code easy. Which means, you can use and mix different code of different developers.
Make extensions easy: If you want to create an extension on top of a feature, you always have one code path, because everything (including the low-level API) should be polyfilled. If you want to extend an abstraction, it might be possible, that you have to extend several code paths (modern and legacy code).
Let the user/developer choose: Webshims lib's polyfills are loaded modular by demand, which means you can mix several polyfills. Consider the following:
A plugin-author needs a storage API and he chooses abstraction code A, because it is good, has an awsome API and is only 5kb. Another plugin author also needs an storage API and uses abstraction code B, it's also nice and also just 5kb. And now you need to use both scripts and you are adding 10kb of useless code, because 80% of all browser already support localStorage and JSON (I would say this is a big fail).
Create stable, reliable polyfills
One big problem in the "polyfilling" world are reliable and production ready polyfills. Webshims Lib takes cross-browser testing and studying the specifications very serious.
Improve the standard
While Webshims lib's polyfills only want to polyfill the gaps and in some cases do some extension work.  If you are doing so, please be so kind and share your code with others.
Further Development
Feel free to fork, report issues, develop implementations/features, develop extensions on top of implemented features or simply use :-).
- improve current implementations
- improve current documentation
- history (pushState etc.)/hashchange (maybe history.js (coming in 1.9))
- make everything more native (this will be more awesome!!! coming in 2.0)


Join the competition camt shining star at College of Arts Media and Technology, Chiang Mai University.
CAMT SHINING STAR 2015 RUN THROUGHGolden medal in competition Taekwondo CMU Freshy Games 2015 at CMU main stadium , Chiang Mai University.
18/11/2015Presenter promote video for College of Arts Media and Technology, Chiang Mai University.
แนะนำวิทยาลัยศิลปะ สื่อ และเทคโนโลยี มหาวิทยาลัยเชียงใหม่Competition of running 4x100 meters for College of Arts Media and Technology, Chiang Mai University.
08/02/2016Join the tradition of CMU Trekking 2016, Chiang Mai University.
[Official] รับน้องขึ้นดอย CAMT 2016 [CMU TREKKING 2016]Staff of College of Arts Media and Technology in tradition of CMU Trekking 2017, Chiang Mai University.
CAMT รับน้องขึ้นดอย '60 : CMU DoiSuthep Trekking 2017Previously in 3 days Agile for Software Development workshop for Academy from Siam Chamnankit , they used web application such as eCommerce check out feature, Digital banking or Car parking management. On this year 2018, the second workshop of the project Give and Take Agile for Software Development for CAMT.
IoT x Agile in 3 days workshop at CAMTJoin the tradition of CMU Trekking 2018, at Wat Phrathat Doi Suthep, Chiang Mai.
CAMT Trekking 2018Project by Faculty of Architecture & College of Arts Media and Technology, Chiang Mai University, Thailand
lannathaicoffeehub.comProject by Faculty of Architecture & College of Arts Media and Technology, Chiang Mai University, Thailand
lannathaicoffeehub.comCollege of Arts Media and Technology, Chiang Mai University
Subcommittee of ACM-ICPC 2016 competition at College of Arts Media and Technology, Chiang Mai University
My hobbies are to be a ‘Hopping’ The hopping is a photographer in coffee shop in my interested,
The most taken a coffee and bakery.


The Technology Detection add-on uses the Wappalyzer rules to detect the technologies used by applications.
Ele funciona de maneira muito semelhante aos complementos do navegador Wappalyzer com as seguintes exceções:
Beside the site selection drop down is an Export button which can be used to export a CSV (comma separated values) file based on the table information currently being displayed. There is also a toggle button which allows users to easily Enable/Disable the Wappalyzer passive scanner.
The toolbar includes an enable/disable toggle button which controls whether the technology detection passive scan rule is functioning or not. This enabled state is persisted between ZAP sessions.
| https://www.wappalyzer.com/ | The Wappalyzer Homepage | |
| https://github.com/wappalyzer/wappalyzer | The Wappalyzer Repository |


Stay Mad is a horde guild located on US Area 52 that is focused on mythic progression while maintaining a bit more of a casual schedule. Success and longevity in this guild rely not only on skill, but on how well you interact with others in the group. Many of us have been playing together for several years, which helps make the guild atmosphere more lighthearted and fun while not detracting from our main goal of progressing at a pace reasonable to our lighter schedule.
Most of our expectations are similar to any others you'll be accustomed to if you have raided with any mid-tier to high-end group. We do not require any alts, but we are certainly not against players keeping up with an additional character that may benefit the group for boss-specific mechanics.  We do not require that you play 40 hours per week. Our members span a large variety of play time, from those that seem to always be on to those you may not see much more than their weekly requirements. We just ask that you are keeping up reasonably with the group and if there's any specific goal requirements you'll be informed in plenty of time to accomplish them.
Having a tight-knit group has long been an appeal of the group. Most people who join end up staying for a long stretch of time. Some new recruits may find this off-putting at first, but we are very open to making new friends and try to avoid cliques and bias as much as possible. Our officers are also generally very approachable and available outside of raid times. At the end of the day we are mostly a group of adults with a similar passion that we want to make as enjoyable as possible.
Here is a list of our general raid information:
We do have a short list of required addons. All accepted applicant will be expected to show up with these already downloaded. If you are not accustomed to a particular addon we will walk you through what we need you to do with it when the time comes.


My interest in web development stemmed from my passion for websites.  Some of my passions are keyboard, music, photography, blogging and filling up a fresh cup of coffee.
Day-To-Day Comfort: HTML5/CSS3/Bootstrap/Django/Python/PHP/Wordpress/Keyboard/Coffee:)
I just look into the world differently through my photography. Love to develop android apps. Ardent fan of yuvan, thala, raja sir.
Feel free to email/tweet me to provide some feedback on my work, give me any suggestions for new web designs and themes, or to just say hello!
You can view more Photos
Created a simple personal blog using Django. You can view the Source code
About me page for personal web site Source code , About me ;) (demo)
Parallax EffectSource code , demo
TextFlow. Simple page with moving text Source code , demo
Simple About us page for startups Source code , demo
Web page using Parallax effect Source code , demo
Home page with parallax effect and a video background Wit Twt TL, demo


Friston-24 motion regressors remove motion-related noise
- Motion correction itself only corrects for spatial noise
- does nothing to correct for signal distortions imposed by motion
- Incorporate the motion parameter estimates and derivatives into the nuisance GLM as regressors
Friston-24 motion regressors improve discriminability
(TODO: add figure)
- Discriminability for SWU4 dataset: $.75 \rightarrow .80$ (460 subjects; $p=.001$)
Adding Compcor Reduces Physiological Noise
- anatomical CompCor, or incorporation of white-matter regressors has been shown to reduce noise from things like pulse and heartbeat
- take top 5 PCs and incorporate as regressors into nuisance GLM
WM compcor regressors Improve Discriminability
wm mask                       regressors
(TODO: add figure)
- Discriminability for SWU4 dataset: $.80 \rightarrow .88$ (460 subjects; $p=0.001$)
Single-Pass Registration does no worse
- registration is just a series of transformations, linear and nonlinear
- no reason to ever apply a transform at intermediate steps; just introduces unnecessary multiplications
- merge transforms as you go and just use the previous transforms to initialize successive operations
- Discriminability for SWU4 dataset: $.875 \rightarrow .878$
Adding Anatomical Preprocessing Improves Brain-Extraction
- I noticed that about 30 subjects of the SWU4 dataset fail in registration due to bad brain extraction
- FSL's BET is limited in what it can do
- Use AFNI's brain-extraction tools to preprocess/brain-extract T1w data
Adding Anatomical Preprocessing Improves Brain-Extraction
(TODO: add figure)
- Discriminability for SWU4 dataset: $.88 \rightarrow (TODO: add)$ ($p = .005$)
- number of registration failures (DICE overlap $< 0.7$): $25 \rightarrow 10$
Showing edges in QA plots strategically makes it easier to visualize registration
- Most people like to see edges when registering brains
- Poor local registrations might not be obvious when you can't see the image beneath the top layer
- Edges are a lot easier to visualize on things like atlases
old                       new
(TODO: add figure)
Local multithreading support makes cluster deployment trivial
- Previously no support for multithreading for the pipeline
- Needed separate bids dirs for each thread, and had to launch each thread manually
- User input: $min(\frac{cores \cdot threads}{core}, RAM/10)$
- Launches an entire BIDs-dir on however many cores you tell it to
Best Pipeline
- func preproc: slicetimer (FSL), mcflirt (FSL)
- anat preproc: 3dUnifize (AFNI, normalize intensities), 3dSkullstrip (AFNI, skullstrip), 3dAutoMask (AFNI, apply skullstrip)
- self registration: flirt (FSL, translational), flirt (FSL, local), fast (segment wm mask), flirt (FSL, bbr using wm mask)
- template registration: flirt (FSL, 12 DOF), FNIRT (FSL, MNI152 config)
- nuisance correction: quadratic, csf mean, wm CompCor, friston-24, highpass filter
By Monday
- Finish running (most of CoRR?) by Monday (at least 10 datasets)
- report discriminability scores, and show compared to best non-GSR CPAC pipeline
- Incorporate these slides into presentation for @gkiar
- Have a list of 5xfigures explained in words and captions for a manuscript


my-counter
A key feature of any user interface is the ability to update its state in response to different events. In Synergy, this process is defined by the object returned from your custom elements factory function.
Lets take another look at the my-counter
example from the home page:
const factory = () => ({
state: { count: 0 },
update: {
increment: ({ count }) => ({
count: count + 1,
}),
})
In the example above, the returned object includes both the state
and update
properties.
State
State
is an object that provides the initial data for your custom element. Any properties defined here can be used directly in the template via text or attribute bindings, which is exactly how the value of count
is included inside the template using text interpolation:
<button :onclick="increment">Count is: {{ count }}</button>
Update
Update
is a dictionary of named state update functions that can be referenced directly in the template as event handlers, as per the :onclick="increment"
binding in the example above.
Each state update function takes the current state as its first argument and returns the next state for the custom element.


Departments
Computer Science
Cognitive Science
Categories
Competitions
Networking
Organizations
Courses
About
Profile
Sign In
Sign In
Email:
Password:
Sign In
Sign Up


Overview
Architecture And Design
Memory Package
Sketch Families
Distinct Counting
CPC Sketches
CPC Examples
HyperLogLog Sketches
HLL Examples
HLL Studies
Theta Sketches
Theta Examples
KMV Tutorial
Set Operations and P-sampling
Accuracy
Size
Speed
Theta Sketch Theory
Tuple Sketches
Tuple Examples
Most Frequent
Frequent Item Sketches
Most Frequent Examples
Frequent Distinct Sketches
Quantiles And Histograms
Quantiles Examples
Quantiles Studies
Quantiles Sketch Theory
Sampling
Sampling Examples
Community
Research


This post is aiming to extend the discussion here. In java, Vector and Collections.synchronizedList are all synchronized randomly-accessable lists. For historical reasons, this redundancy exists and is reserved until now. How are they different from each other?
Differences
The main difference between them is how the underlying data is stored.
Collections.synchronizedList is a wrapper class around your current List implementation, which means you don't copy data to another data structure and you keep underlying structure intact.
public staticList synchronizedList(List list) { return (list instanceof RandomAccess ? new SynchronizedRandomAccessList (list) : new SynchronizedList (list)); } static class SynchronizedList extends SynchronizedCollection implements List { private static final long serialVersionUID = -7754090372962971524L; final List list; SynchronizedList(List list) { super(list); this.list = list; } // other staff .... }
The idea is implemented at line 15. Line 14 ensures the synchronization at the superclass SynchronizedCollection. We are able to use all APIs provided by List
In case of a Vector, it actually holds the data internally. So if you want to take Vector as a wrapper of Arraylist to obtain synchronization, it would less efficient because it will make a copy of data. Another disadvantage of a Vector object is that it's an instance of RandomAccess Interface and therefore if a Vector object wraps a non-RandomAccess list like LinkedList, LinkedList will copy its values to an array by calling toArray method as shown at line 2. Thus the underlying LinkedList object loses its properties.
public Vector(Collection extends E> c) { elementData = c.toArray(); elementCount = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, elementCount, Object[].class); }
The wrapper synchronizedList is going to equip a list. It wraps not only a RandomAccess list like ArrayList but also a sequential-access list like LinkedList.
public staticList synchronizedList(List list) { return (list instanceof RandomAccess ? new SynchronizedRandomAccessList (list) : new SynchronizedList (list)); }
In addition to SynchronizedList, java.util.Collections also offers more synchronized wrappers such as
- synchronizedCollection
- synchronizedMap
- synchronizedSet
- synchronizedSortedMap
- synchronizedSortedSet
where synchronizedCollection is the superclass of all others.


{% load static %}
PyFiddle is a free lightweight Python IDE to run and share Python scripts with some nifty features, created with love by pythonista Priyank Pulumati and Beautiful Code
Unfortunately, as of now, Pyfiddle is not supported on lower resolution devices, please use a device with a higher resolution.


--- layout: default title: MAYDAY.US - About Us permalink: /about_us/ ---
Mayday PAC (MAYDAY.US) is a movement of citizens dedicated to ending the system of corruption in Washington, D.C. by changing the way campaigns are funded.
In 2014, Mayday launched as the “super PAC to end all super PACs.” We crowdfunded over $11,000,000 from over 68,000 individual contributions. In eight races across the country, we used these donations from thousands of ordinary Americans to support reformers in an effort to overcome the influence of special interests. This experience taught us important lessons about the most effective ways to rally members of Congress. We are bringing that same experimental, data-driven spirit to our new campaign.
With our new plan to activate voters directly, the potential to inspire leaders is even greater. Mayday will leverage the skills, ideas, and power of our community to win this fight. We are counting on your energy and ideas to make this campaign a success, so please get involved and take action to pass reform.


Select these boxes to show / hide the features. Change the parameters here to show/hide the features below.
These Features exist
The features shown here are visible according to the data above. The others are hidden.


My name is Philip Akpeki, i am a software developer based in Lagos, Nigeria.
I have skills ranging from HTML, CSS , Javascript, AngularJs, PHP and Python
You can find HERE a list of project i have handled.
also find my Github projects here.


| Class | Description |
|---|---|
| CallTimeLogger |
This class is responsible for timing all invocations of publicly-exposed
methods of the webapp.
|
| CallTimingFilter |
Logs the time it takes to service HTTP calls into Taverna Server.
|
| CapabilityLister |
Utility for listing the capabilities supported by this Taverna Server
installation.
|
| CertificateChainFetcher |
Obtains the certificate chain for an arbitrary SSL service.
|
| Contextualizer |
Convert a string (URL, etc) to a version that is contextualized to the
web-application.
|
| DerbyUtils |
Utility class, used to make Derby less broken.
|
| FilenameUtils |
Utility functions for getting entries from directories.
|
| FlushThreadLocalCacheInterceptor | |
| InvocationCounter |
This class is responsible for counting all invocations of publicly-exposed
methods of the webapp.
|
| JCECheck |
Trivial bean that checks for whether the JCE policy files that allow
unlimited strength security are present, and warns in the log if not.
|
| JDOSupport<T> |
Simple support class that wraps up and provides access to the correct parts
of JDO.
|
| JDOSupport.PersistenceManagerBuilder |
Manages persistence managers in a way
that doesn't cause problems when the web application is unloaded.
|
| JDOSupport.TransactionAspect |
Manages integration of JDO transactions with Spring.
|
| LoggingDerbyAdapter |
Evil hack to allow logging of the DDL spat out to Derby.
|
| OneShotThread | |
| RestUtils |
Utilities that make it easier to write REST services.
|
| RuntimeExceptionWrapper |
Aspect used to convert runtime exceptions into
a form that can be nicely conveyed to the outside world as HTTP errors.
|
| UsernamePrincipal |
A simple serializable principal that just records the name.
|
| WebappAwareDataSource |
Add some awareness of the context so that we can locate databases internally
to the webapp.
|
| WSDLHeadOptionsInterceptor |
Thunk for TAVSERV-293.
|
| X500Utils |
Support class that factors out some of the messier parts of working with
X.500 identities and X.509 certificates.
|
| Annotation Type | Description |
|---|---|
| CallTimeLogger.PerfLogged |
Mark methods that should be counted by the invocation counter.
|
| InvocationCounter.CallCounted |
Mark methods that should be counted by the invocation counter.
|
| JDOSupport.WithinSingleTransaction |
Mark a method (of a subclass of
JDOSupport ) as having a
transaction wrapped around it. |
Copyright © 2015–2018 The Apache Software Foundation. All rights reserved.


Hooks are programs you can place in a hooks directory to trigger actions at certain points in git’s execution.
$GIT_DIR/hooks/* (or git config core.hooksPath
/*)
Before Git invokes a hook, it changes its working directory to either $GIT_DIR in a bare repository or the root of the working tree in a non-bare repository. An exception are hooks triggered during a push (pre-receive, update, post-receive, post-update, push-to-checkout) which are always executed in $GIT_DIR.
pre-commit: invoked before git commit
pre-push: invoked before push (can stop push)
git rebase: reapply all commits from current branch to tip of another branch.
Note: - These commits are new commits, not identical to previous commits. - Golden rule: Never rebase a branch shared by others


|
|
IFXScreenSpaceMetric Class ReferenceInheritance diagram for IFXScreenSpaceMetric:
List of all members.
|
Public Member Functions |
| | IFXScreenSpaceMetric () |
| virtual void | EvaluateTriangle (IFXTQTTriangle *pTriangle, Action *pAction) |
| void IFXAPI | UpdateViewpoint (IFXVector3 &pCameraX, IFXVector3 &pCameraY, IFXVector3 &pCameraZ, IFXVector3 &pCameraPos, F32 fAspect, F32 fFieldOfView) |
| F32 IFXAPI | GetPixelTolerance () |
| void IFXAPI | SetPixelTolerance (F32 factor) |
| F32 IFXAPI | GetFieldofView () |
| void IFXAPI | SetFieldofView (F32 degrees) |
| BOOL IFXAPI | GetViewpointLock () |
| void IFXAPI | SetViewpointLock (BOOL state) |
Private Member Functions |
| void | FindTriangleCenter (IFXVector3 ¢er, IFXTQTVertex **ppVertex) |
| void | EvaluateGeometricError (IFXTQTTriangle *pTriangle, IFXTQTVertex **ppVertex, IFXVector3 &faceNormal, F32 delsquared, F32 *pLeftmetric, F32 *pRightmetric) |
| bool | GetFaceNormal (IFXTQTTriangle *pTriangle, IFXTQTVertex **ppVertex, IFXVector3 &faceNormal) |
| IFXAdaptiveMetric::Action | ScreenSpace (IFXTQTTriangle *pTriangle, IFXTQTVertex **ppVertex) |
Private Attributes |
| IFXVector3 | m_eye |
| IFXVector3 | m_xdir |
| IFXVector3 | m_ydir |
| IFXVector3 | m_zdir |
| F32 | m_fConstant |
| F32 | m_fPixelTolerance |
| F32 | m_fFOV |
| IFXVector3 | m_frustum [4] |
| F32 | m_frustumdist [4] |
| IFXVector3 | m_frustumEdge [4] |
| BOOL | m_bLockViewpoint |
| F32 | m_fModelSize |
| IFXVector3 | m_fModelCenter |
Constructor & Destructor Documentation
| IFXScreenSpaceMetric::IFXScreenSpaceMetric |
( |
|
) |
|
|
Member Function Documentation
|
|
- Todo:
- : find the angle this edge boundary forms with its neighbor...
|
| void IFXScreenSpaceMetric::EvaluateTriangle |
( |
IFXTQTTriangle * |
pTriangle, |
|
|
Action * |
pAction |
|
) |
[virtual] |
|
| F32 IFXScreenSpaceMetric::GetFieldofView |
( |
|
) |
[virtual] |
|
| F32 IFXScreenSpaceMetric::GetPixelTolerance |
( |
|
) |
[virtual] |
|
| BOOL IFXScreenSpaceMetric::GetViewpointLock |
( |
|
) |
[virtual] |
|
|
|
This method returns a boolean indicating whether or not the viewpoint is locked.
- Returns:
- BOOL
- TRUE - The viewpoint is locked.
- FALSE - The viewpoint is not locked.
Implements IFXScreenSpaceMetricInterface. |
|
|
- Todo:
- : these should already be normalized?
|
| void IFXScreenSpaceMetric::SetFieldofView |
( |
F32 |
degrees |
) |
[virtual] |
|
|
|
This method sets the cameras field of view.
- Parameters:
-
| A | F32 denoting the cameras field of view. |
- Returns:
- void
Implements IFXScreenSpaceMetricInterface. |
| void IFXScreenSpaceMetric::SetPixelTolerance |
( |
F32 |
factor |
) |
[virtual] |
|
|
|
This method sets the pixel tolerance ratio.
- Parameters:
-
| A | F32 denoting the pixel tolerance ratio. |
- Returns:
- void
Implements IFXScreenSpaceMetricInterface. |
| void IFXScreenSpaceMetric::SetViewpointLock |
( |
BOOL |
state |
) |
[virtual] |
|
|
|
This method sets the boolean indicating whether or not to lock viewpoint.
- Parameters:
-
| BOOL |
- TRUE - Lock the viewpoint.
- FALSE - Do not lock the viewpoint.
|
Implements IFXScreenSpaceMetricInterface. |
|
|
This method updates the cameras viewpoint.
- Parameters:
-
| pCameraX | An IFXVector3 reference to the X direction of the camera. |
| pCameraY | An IFXVector3 reference to the Y direction of the camera. |
| pCameraZ | An IFXVector3 reference to the Z direction of the camera. |
| pCameraPos | An IFXVector3 reference to the position of the camera. |
| fAspect | A F32 denoting the cameras aspect ratio. |
| fFieldOfView | A F32 denoting the cameras field of view. |
- Returns:
- void
Implements IFXScreenSpaceMetricInterface. |
Member Data Documentation
© 1999 - 2006 Intel Corporation. All rights reserved.
* Other names and brands may be claimed as the property of others.
|
|


{{ article.title }}
{{ article.locale_date }}{% if article.tags %} | Tags: {% for tag in article.tags %} {{ tag }}{% if not loop.last %},{% endif %} {% endfor %} {% endif %}
{% if article.author and SHOW_ARTICLE_AUTHOR %} By {{ article.author }} {% endif %}If you enjoyed this post, I'd love to hear from you. I'm open to topic ideas, writing improvements, fact checks, guest posts, conversations about beer or computer science, and pretty much anything else. Email me!


?0
1
2
3
4
5
lem
6
7
8
9
10
The
New
York
copyright
reserved
Botanical
Garden
FlvORA
CUBANA.
Province
of
Santa
Clara,
district
of
Cienfuegos.
%/Ay
S2P5í
botanical
GARDEN
01333883ªÕ
COLL*
ROB
COMBS.
/'Àí44
fry-
z
-
01333883
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


compound-changelog
- Changes in CompoundJS
Docs in roff (man). Change compound help
command to proxy request to man
.
Unfortunately compound have optional ronn
rubygem dependency.
New API for middleware injections.
All tests rewritten. Mocha is new default test engine.
Generators, assets compiler, clientside moved to separate packages. Refactor and speedup render.
icon, imageTag, metaTag, anchor, contentFor, button.
New generators structure. Fully rewritten by Sascha Gehlich.
Finally we have correct controllers with inheritance, proper require, debug and meta-programming. Added predefined meta-controllers.
A lot of restructuring and rewriting for clienside, separate server and client loading logic.
Fixes in i18n, helpers, logging, docs, etc..
No more weird npmfile with require
problems.
Basic middleware to support nodejs domains.
Now any express-friendly templating engine supported.
View helpers formTag, formFor and fieldsFor doesn require blocks.
A lot of bugfixes after rewriting
Major API changes started at this point. No backwards compatibility with RailwayJS.
Static website generated from markdown added to repository
Now built-in core. Allows to generate css/js from assets stored in app/assets directory
Switch to latest express
Improved loading process, now utilizes events API based on nodejs event emitter


Rebels kill 8 in eastern Congo as residents protest violence
BENI, Congo (AP) - Congo’s army says rebels have killed at least eight people and kidnapped about a dozen others in an attack in the eastern city of Beni.
Residents angered by the ongoing violence have attacked trucks belonging to the United Nations peacekeeping mission and barricaded roads.
Army spokesman Mak Hazukay Mongba says the Allied Democratic Forces rebels staged the assault overnight Tuesday into Wednesday. He says the army fought back and pushed out the rebels.
Mongba says the rebels are trying to kidnap residents to dissuade them from cooperating with the army and sharing intelligence that has helped a new military offensive.
The World Health Organization is expressing concern that such attacks continue to disrupt efforts to contain the deadly Ebola outbreak in the area.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


FrontEnd
AR
Multimedia Design
Developed a token for the Binance Smart Chain using Solidity + Remix
Developed a "trust" smart contract for the Ethereum Blockchain using Solidity + Remix
Mobile wireframe concept for Plant.r application
Desktop wireframe concept for Plant.r application
Some representative placeholder content for the first slide.
Some representative placeholder content for the second slide.
Some representative placeholder content for the third slide.
Project for Modulus Architects using Photoshop


Search
Preparing search index...


|
Cooperative Futures
|
A class to encapsulate a resultless asynchronous task. More...
#include <coopfuture.hpp>
Public Member Functions | |
| void | setResult () throw (FutureAlreadyFulfilled) |
| Fulfills a succesful Future. More... | |
| ~Future () | |
| Class destructor. More... | |
| void | await () throw (ErrorType) |
| Returns the underyling result/exception, blocking if necessary. More... | |
| Public Member Functions inherited from fut::FutureBase< void *, ErrorType > | |
| FutureBase (Scheduler &sched) | |
| A Future is constructed by providing a scheduler on which to resolve the value, if it is not provided before it is needed. More... | |
| void | setError (ErrorType) throw (FutureAlreadyFulfilled) |
| Fulfills an unsuccesful Future with the exception to throw. More... | |
| void | setUnexpected () throw (FutureAlreadyFulfilled) |
| Future was fulfilled with an exception outside of its scope. More... | |
Protected Types | |
| typedef FutureBase< void *, ErrorType >::State | State |
| Protected Types inherited from fut::FutureBase< void *, ErrorType > | |
| enum | State |
Additional Inherited Members | |
| Protected Member Functions inherited from fut::FutureBase< void *, ErrorType > | |
| void | complete () throw (FutureAlreadyFulfilled) |
| Protected Attributes inherited from fut::FutureBase< void *, ErrorType > | |
| Scheduler & | scheduler |
| The scheduler to invoke if blocking is necessary. | |
| State | state |
| The current state, determines which view of the union member is valid. | |
| union fut::FutureBase::Contents | contents |
| Singleton instantiation of Contents. | |
A class to encapsulate a resultless asynchronous task.
This is a specialization of the Future class. It is used as a form of barrier, where the Future will not have a result set on it but can throw an error and can be blocked on.
| fut::Future< void, ErrorType >::~Future | ( | ) |
Class destructor.
If the outcome of the Future is set then destroy the result or the exception as appropriate.
| void fut::Future< void, ErrorType >::await | ( | ) | ||
| throw | ( | ErrorType | ||
| ) |
| void fut::Future< void, ErrorType >::setResult | ( | ) | ||
| throw | ( | FutureAlreadyFulfilled | ||
| ) |


Lawrence Guintu
Project Portfolio
Lawrence is an undergraduate student majoring in Computer Science at UC San Diego.
Projects
Sign up for Classes Android Application (WIP)
...


This is the reference documentation for initialization and termination of the library, version management and error handling. For more task-oriented information, see the Introduction to the API.
Modules | |
| Error codes | |
| Error codes. | |
Macros | |
| #define | GLFW_TRUE 1 |
| One. More... | |
| #define | GLFW_FALSE 0 |
| Zero. More... | |
| #define | GLFW_JOYSTICK_HAT_BUTTONS 0x00050001 |
| Joystick hat buttons init hint. More... | |
| #define | GLFW_COCOA_CHDIR_RESOURCES 0x00051001 |
| macOS specific init hint. More... | |
| #define | GLFW_COCOA_MENUBAR 0x00051002 |
| macOS specific init hint. More... | |
Typedefs | |
| typedef void(* | GLFWerrorfun) (int error_code, const char *description) |
| The function pointer type for error callbacks. More... | |
Functions | |
| int | glfwInit (void) |
| Initializes the GLFW library. More... | |
| void | glfwTerminate (void) |
| Terminates the GLFW library. More... | |
| void | glfwInitHint (int hint, int value) |
| Sets the specified init hint to the desired value. More... | |
| void | glfwGetVersion (int *major, int *minor, int *rev) |
| Retrieves the version of the GLFW library. More... | |
| const char * | glfwGetVersionString (void) |
| Returns a string describing the compile-time configuration. More... | |
| int | glfwGetError (const char **description) |
| Returns and clears the last error for the calling thread. More... | |
| GLFWerrorfun | glfwSetErrorCallback (GLFWerrorfun callback) |
| Sets the error callback. More... | |
| #define GLFW_VERSION_MAJOR 3 |
The major version number of the GLFW header. This is incremented when the API is changed in non-compatible ways.
| #define GLFW_VERSION_MINOR 3 |
The minor version number of the GLFW header. This is incremented when features are added to the API but it remains backward-compatible.
| #define GLFW_VERSION_REVISION 8 |
The revision number of the GLFW header. This is incremented when a bug fix release is made that does not contain any API changes.
| #define GLFW_TRUE 1 |
This is only semantic sugar for the number 1. You can instead use 1
or true
or _True
or GL_TRUE
or VK_TRUE
or anything else that is equal to one.
| #define GLFW_FALSE 0 |
This is only semantic sugar for the number 0. You can instead use 0
or false
or _False
or GL_FALSE
or VK_FALSE
or anything else that is equal to zero.
| #define GLFW_JOYSTICK_HAT_BUTTONS 0x00050001 |
Joystick hat buttons init hint.
| #define GLFW_COCOA_CHDIR_RESOURCES 0x00051001 |
macOS specific init hint.
| #define GLFW_COCOA_MENUBAR 0x00051002 |
macOS specific init hint.
| typedef void(* GLFWerrorfun) (int error_code, const char *description) |
This is the function pointer type for error callbacks. An error callback function has the following signature:
| [in] | error_code | An error code. Future releases may add more error codes. |
| [in] | description | A UTF-8 encoded string describing the error. |
| int glfwInit | ( | void | ) |
This function initializes the GLFW library. Before most GLFW functions can be used, GLFW must be initialized, and before an application terminates GLFW should be terminated in order to free any resources allocated during or after initialization.
If this function fails, it calls glfwTerminate before returning. If it succeeds, you should call glfwTerminate before the application exits.
Additional calls to this function after successful initialization but before termination will return GLFW_TRUE
immediately.
GLFW_TRUE
if successful, or GLFW_FALSE
if an error occurred.Contents/Resources
subdirectory of the application's bundle, if present. This can be disabled with the GLFW_COCOA_CHDIR_RESOURCES init hint.LC_CTYPE
category of the application locale according to the current environment if that category is still "C". This is because the "C" locale breaks Unicode text input.| void glfwTerminate | ( | void | ) |
This function destroys all remaining windows and cursors, restores any modified gamma ramps and frees any other allocated resources. Once this function is called, you must again call glfwInit successfully before you will be able to use most GLFW functions.
If GLFW has been successfully initialized, this function should be called before the application exits. If initialization fails, there is no need to call this function, as it is called by glfwInit before it returns failure.
This function has no effect if GLFW is not initialized.
| void glfwInitHint | ( | int | hint, |
| int | value | ||
| ) |
This function sets hints for the next initialization of GLFW.
The values you set hints to are never reset by GLFW, but they only take effect during initialization. Once GLFW has been initialized, any values you set will be ignored until the library is terminated and initialized again.
Some hints are platform specific. These may be set on any platform but they will only affect their specific platform. Other platforms will ignore them. Setting these hints requires no platform specific headers or functions.
| [in] | hint | The init hint to set. |
| [in] | value | The new value of the init hint. |
| void glfwGetVersion | ( | int * | major, |
| int * | minor, | ||
| int * | rev | ||
| ) |
This function retrieves the major, minor and revision numbers of the GLFW library. It is intended for when you are using GLFW as a shared library and want to ensure that you are using the minimum required version.
Any or all of the version arguments may be NULL
.
| [out] | major | Where to store the major version number, or NULL . |
| [out] | minor | Where to store the minor version number, or NULL . |
| [out] | rev | Where to store the revision number, or NULL . |
| const char * glfwGetVersionString | ( | void | ) |
This function returns the compile-time generated version string of the GLFW library binary. It describes the version, platform, compiler and any platform-specific compile-time options. It should not be confused with the OpenGL or OpenGL ES version string, queried with glGetString
.
Do not use the version string to parse the GLFW library version. The glfwGetVersion function provides the version of the running library binary in numerical format.
| int glfwGetError | ( | const char ** | description | ) |
This function returns and clears the error code of the last error that occurred on the calling thread, and optionally a UTF-8 encoded human-readable description of it. If no error has occurred since the last call, it returns GLFW_NO_ERROR (zero) and the description pointer is set to NULL
.
| [in] | description | Where to store the error description pointer, or NULL . |
| GLFWerrorfun glfwSetErrorCallback | ( | GLFWerrorfun | callback | ) |
This function sets the error callback, which is called with an error code and a human-readable description each time a GLFW error occurs.
The error code is set before the callback is called. Calling glfwGetError from the error callback will return the same value as the error code argument.
The error callback is called on the thread where the error occurred. If you are using GLFW from multiple threads, your error callback needs to be written accordingly.
Because the description string may have been generated specifically for that error, it is not guaranteed to be valid after the callback has returned. If you wish to use it after the callback returns, you need to make a copy.
Once set, the error callback remains set even after the library has been terminated.
| [in] | callback | The new callback, or NULL to remove the currently set callback. |
NULL
if no callback was set.Last update on Fri Jul 22 2022 for GLFW 3.3.8


We analyze, design, plan and execute - and then evaluate, improve and start a new cycle. We believe that the path to success is to understand that the process is continuous, seeking to build long-term relationships in which our customers feel supported by someone who cares about their business as much as them.
We define a tailored strategy for each client, define the technology and project structure based on the client needs. Once the client validates and agrees with it, we are ready to achive...
We develop your product relying on agile methodologies and the expertise of our labs. Our team of experts is organized in labs which focus on different industry and technology verticals. Throughout the project, we are in constant touch with our clients, sharing the progress and getting their feedback along the way.


--- layout: "page" title: About me subtitle: "All About Shantonu" css: "/css/index.css" avatar: "/img/picture.jpg" meta-title: "Performance Engineer/SDET/Java Developer" comments: true ---
Shantonu is working as Lead Software Test Automation Engineer at EPAM.com.
Previously he worked as a Test Automation Architect at Living Sky Technologies ,a Lead Performance Engineer at Ensured.io, a Sr. SDET(Automation & Performance) for Luxoft (On site AT&T at NJ, USA and UBS at Krakow,Poland) , Relisource, KAZ Software, BJIT. Before moving to Europe in 2014, he was founder director of Dhaka based a start-up QualitySofts . He was also Test Automation consultant in several reputed companies & Govt projects (hi-tech park,LICT, BITM, BASIS). He started his career as an Asst. Software Engineer in 2008 . Before moving to software industry , he was a Computer Teacher in Oxford International School .
He has attended in several professions trainings on Java, Dotnet,Python,Software Design & Architecture, Agile Testing, Web Security, ISTQB during his professional career. Shantonu used to participate monthly online meetup with Bangladesh software testing professionals groups SQABD,Software QC and java user group Bangladesh (jugbd) . Here is his Youtube Channel
Shantonu has 4 year bachelor's degree majoring Computer Science from ISTT which is an Institute under National University of Bangladesh
This is shantonu’s personal blog .If you have any interesting problem related to R&D on new technology or Automation where you need an external opinion, you may contact him . He will try to answer on weekends. He is also available to hire for interesting work via UpWork .
If you like to setup a quick call/meeting with me, please schedule here .
Memberships:


vtk_animation module¶
-
class
vtk_animation.
CalculatorThread
(dir_q, result_q, filter_q, socket)¶ Bases:
vtk_animation.WorkerThread
-
run
()¶ Method representing the thread’s activity.
You may override this method in a subclass. The standard run() method invokes the callable object passed to the object’s constructor as the target argument, if any, with sequential and keyword arguments taken from the args and kwargs arguments, respectively.
-
-
class
vtk_animation.
Simulate
(robot_update, dir_q, result_q, new_actors, socket)¶ Bases:
object
-
simulate
()¶
-
-
class
vtk_animation.
WorkerThread
(dir_q, result_q, filter_q, socket)¶ Bases:
threading.Thread
-
join
(timeout=None)¶ Wait until the thread terminates.
This blocks the calling thread until the thread whose join() method is called terminates – either normally or through an unhandled exception or until the optional timeout occurs.
When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof). As join() always returns None, you must call is_alive() after join() to decide whether a timeout happened – if the thread is still alive, the join() call timed out.
When the timeout argument is not present or None, the operation will block until the thread terminates.
A thread can be join()ed many times.
join() raises a RuntimeError if an attempt is made to join the current thread as that would cause a deadlock. It is also an error to join() a thread before it has been started and attempts to do so raises the same exception.
-
run
()¶ Method representing the thread’s activity.
You may override this method in a subclass. The standard run() method invokes the callable object passed to the object’s constructor as the target argument, if any, with sequential and keyword arguments taken from the args and kwargs arguments, respectively.
-
-
vtk_animation.
axesUniversal
()¶


Product 1
Product 2
Product 3
Product 4
Product 5
Product 6
Product 7
Product 8
Product 9
Product 10
Product 11
Product 12
Product 13
Product 14


{{partial "head/head.html"}} {{ $vendorsCSS := partial "head/vendor-css.html" . }} {{partial "pages/pages-css.html"}}


Pseudo Wire Reference |
The Standard Lua Package (SLP) is the addon that is included with Pseudo Wire.
The Standard Lua Package provides only basic components for use in vanilla (default) Pseudo Wire. The SLP contains lots of minimalistic componented under nine basic categories;
Math
Comparison
Logic
I/O (Input/Output)
Bitwise Operations
Storage (Memory)
Time
Trigonometry
Graphics
An explaination of each category can be found here.


Hi! My full name is Volodymyr Dziubak, I am passionate about interaction design and modern trends in front-end development. Here’s the list of things I enjoy most:
Instead of building navigation out of features list, I try to build app structure based on user roles and most common actions. This allows to minify the factor of user choice and makes interaction process intuitive.
As HTML/CSS purist I am constantly learning how to make code more clean, scalable, and maintainable. At the moment I use SASS and stick to a mixture of SMACSS and OOCSS paradigms, and BEM naming convention.
I use JQuery and JQueryUI libraries for DOM maniopulation and basic interaction handling. I use Knockout JS library for more complex interactions, and EmberJS for full-scale client-side applications.
Here you can find some of the projects I’ve made. All of them were made with different tools in different periods of my career and each has taught me something new about development for web.


Find ATM Locations
[Num Notifications]
You have
[Num Notifications]
Notification[s]
[Msg Content]
0
You have 0 Mails
My Profile
Change Password
Logout
×
Welcome


The word “bootstrap” comes from an old story about a hero - Baron Munchausen - who is riding around on his horse in a forest and suddenly gets stuck in a swamp. He screams for help but there is no one around who hears his voice! Luckily our hero does not give up and gets a great idea: “what if I just pull myself out of this swamp?”. He grabs the straps of his boots and pulls himself loose. Fantastic - he just invented bootstrapping.
Physics-defying stories aside, bootstrapping has become a common term for something seemingly impossible or counterintuitive. In this blogpost I will try to generate an intuition for the properties of statistical bootstrapping - resampling from your data to approximate resampling from a population.
In order to explain bootstrapping, we need to generate an example. Let’s assume we want to know the average height of all the people in the Netherlands. With the power of R
we can easily generate a population of 17104879 people (according to CBS, the amount of registered inhabitants of the Netherlands as per the creation of this post2). The Dutch are just about the tallest people on the planet, where the men are 180,7 centimeters tall, on average3.
Here is some more information about my population. For the sake of simplicity let’s assume that all inhabitants are actually men (which would be a disaster). The tallest Dutch man is 223 centimeters4 (which is very tall) and the shortest Dutch man is ridiculously hard to find on the internet. I have an intuition that it is further away from the mean of 180.7, which implies some negative skewness, but that’s not what this post is about so let’s also assume we have a non-skewed normal distribution.
After some fiddling with the standard deviation variable, I simulated the following population:
# generate population data
set.seed(3665364)
pop <- rnorm(17104879, mean = 180.7, sd = 7.5)
# plot the distribution
hist(pop, freq = FALSE, ylim = c(0, 0.06), xlim = c(120, 240), axes = FALSE,
breaks = 30, xlab = "", ylab = "", main = "", col = "#1E90FF88", border = "#00008B")
polygon(density(pop, from = 130, to = 230), cex = 2, col = "#1E90FF44", border = "#00008B",
lwd = 2)
abline(v = 180.7, col = "white", lwd = 2)
axis(1, at = c(130, 155, 180, 205, 230))
mtext("Population height distribution", side = 3, line = 1, cex = 1.8)
mtext("N = 17104879", side = 2, line = 0)
mtext("Height in cm", side = 1, line = 3)
Let’s look how tall the tallest man from the hypothetical all-men Netherlands is, along with some other statistics!
cat(" Statistics about the population:\n", "--------------------------------\n",
"The shortest person is ", min(pop), " cm tall.\n", "Mean height is ", mean(pop),
" cm.\n", "Median height is ", median(pop), " cm.\n", "The 5th and 95th percentiles are ",
quantile(pop, probs = c(0.05, 0.95)), "cm.\n", "The tallest person is ",
max(pop), " cm tall.")
## Statistics about the population:
## --------------------------------
## The shortest person is 142.0121 cm tall.
## Mean height is 180.6979 cm.
## Median height is 180.698 cm.
## The 5th and 95th percentiles are 168.3612 193.0287 cm.
## The tallest person is 222.2139 cm tall.
That seems close enough to something I’d consider a population.
Normally, when we want to estimate some population parameter such as the mean height, we cannot measure all persons. Therefore, we create a representative sample of persons from this population that we can measure. The size of our sample (\(N\)) should depend on how precise we want our final estimate to be - the standard error of a statistic depends directly on the number of persons in our sample. For the mean, the standard error is usually calculated as follows:
\[ se_\bar{x} = \frac{\hat{\sigma}}{\sqrt{N}}\text{, where } \hat{\sigma} = \sqrt{\frac{1}{N-1}\sum_{i=1}^N(x_i-\bar{x})^2} \]
With increasing \(N\), the \(\hat{\sigma}\) becomes smaller, and the \(se_\bar{x}\) becomes smaller as well. In words: with a larger sample comes an increase in precision (a reduction in error).
We can display the precision in the form of confidence intervals (CI). A \(p\%\) CI about an estimate indicates the area in which upon infinitely repeated sampling the TRUE parameter lies \(p\%\) of the time. In other words, if we would redo our experiment infinite amount of times, a 95% confidence interval will cover the true parameter in 95% of the replications.5
In real life, there is of course no such thing as infinite resampling; we only sample once and use the CI as an indication of precision. Let’s look at how the precision of the mean estimate increases as we take larger samples from the above population.
# randomly sample from population
small <- sample(pop, 20)
medium <- sample(pop, 100)
large <- sample(pop, 1000)
# calculate means
means <- mean(small)
meanm <- mean(medium)
meanl <- mean(large)
# calculate standard errors
ses <- sd(small)/sqrt(length(small))
sem <- sd(medium)/sqrt(length(medium))
sel <- sd(large)/sqrt(length(large))
# calculate confidence intervals
CIs <- c(means - 1.96 * ses, means + 1.96 * ses)
CIm <- c(meanm - 1.96 * sem, meanm + 1.96 * sem)
CIl <- c(meanl - 1.96 * sel, meanl + 1.96 * sel)
# initialise plot
plot(0, xlim = c(170, 190), ylim = c(0, 4), bty = "L", xlab = "Height in cm",
ylab = "", axes = F, cex = 1.3, main = "Effect of sampling on CI")
axis(1, cex = 1.3)
# horizontal lines
lines(CIl, y = c(1, 1), lwd = 2)
lines(CIm, y = c(2, 2), lwd = 2)
lines(CIs, y = c(3, 3), lwd = 2)
# points
points(c(means, meanm, meanl), c(3, 2, 1), bg = "black", pch = 24)
# vertical lines
lines(c(CIl[1], CIl[1]), c(0.9, 1.1), lwd = 2)
lines(c(CIl[2], CIl[2]), c(0.9, 1.1), lwd = 2)
lines(c(CIm[1], CIm[1]), c(1.9, 2.1), lwd = 2)
lines(c(CIm[2], CIm[2]), c(1.9, 2.1), lwd = 2)
lines(c(CIs[1], CIs[1]), c(2.9, 3.1), lwd = 2)
lines(c(CIs[2], CIs[2]), c(2.9, 3.1), lwd = 2)
# true mean
abline(v = mean(pop), lwd = 2, lty = 3)
# text
text(y = c(1, 2, 3), x = 172, labels = c("N = 1000", "N = 100", "N = 20"), pos = 4,
cex = 1.3)
As you can see, the CI from each sample covers the true population value in this case. We can create these confidence intervals because we know the sampling distribution of the mean - the distribution of the mean that arises upon repeated sampling. For means of a normally distributed population, the sampling distribution is the familiar Student’s t-distribution. We use the probability density to determine our 95% CI (the 1.96
in the code above).
But what if we don’t exactly know what the sampling distribution is? For example, what happens if we do not have a normally distributed population? It turns out there is another way of generating CIs.
The bootstrap has these steps:
Huh? Only one step? Is it that simple?
Yes:
# Let's bootstrap 10000 times!
mean_sampling_distribution <- numeric(10000)
for (i in 1:10000) {
bootstrap_sample <- sample(medium, replace = T)
mean_sampling_distribution[i] <- mean(bootstrap_sample)
}
opt <- par(mar = c(5, 1, 4, 1))
hist(mean_sampling_distribution, freq = FALSE, xlim = c(175, 187), axes = FALSE,
breaks = 30, xlab = "Height in cm", ylab = "", main = "Bootstrap Sampling Distribution",
col = "#1E90FF88", border = "#00008B")
axis(1, at = c(175, 178, 181, 184, 187))
Great! Now we have an empirical sampling distribution. What do we do now in order to get an estimate of our precision in the form of a confidence interval? That is simple too: sort the means attained from the bootstrap samples from low to high, and look at the 2.5th and 97.5th percentile. This yields a 95% bootstrap CI!
CIbootstrap <- quantile(mean_sampling_distribution, probs = c(0.025, 0.975))
# plot
plot(0, xlim = c(170, 190), ylim = c(0, 3), bty = "L", xlab = "Height in cm",
ylab = "", axes = F, cex = 1.3, main = "Bootstrap CI")
axis(1, cex = 1.3)
# original CI
lines(CIm, y = c(2, 2), lwd = 2)
lines(c(CIm[1], CIm[1]), c(1.9, 2.1), lwd = 2)
lines(c(CIm[2], CIm[2]), c(1.9, 2.1), lwd = 2)
# bootstrap CI
lines(CIbootstrap, y = c(1, 1), lwd = 2, col = "dark green")
lines(c(CIbootstrap[1], CIbootstrap[1]), c(0.9, 1.1), lwd = 2, col = "dark green")
lines(c(CIbootstrap[2], CIbootstrap[2]), c(0.9, 1.1), lwd = 2, col = "dark green")
# true mean
abline(v = mean(pop), lwd = 2, lty = 3)
# text
text(y = c(1, 2), x = 172, labels = c("Bootstrap CI", "Theoretical CI"), pos = 4,
cex = 1.3)
# points
points(c(meanm, meanm), c(2, 1), bg = c("black", "dark green"), col = c("black",
"dark green"), pch = 24)
As you can see, that’s indeed very close to the original theoretical CI.
The advantage of this method is that this does not require the researcher to know the exact form of the sampling distribution. We can now create CIs (and thereby an estimate of precision) for nearly any statistic that we think about, such as (a) the fifth percentile, (b) the median, (c) the ninety-ninth percentile, (d) this completely arbitrary statistic called van kesteren measure that I just came up with: \[\hat{k} = \bar{x}\cdot\frac{1}{N}\sum_{i=1}^N |x_i^\frac{1}{3}-\sqrt{\text{median}(x)}|\]
Probably there are analytical solutions to the sampling distributions of these measures (and I think it is likely that they have been derived at some point in the 1940s) but I don’t know them so I’ll bootstrap:
vkmeasure <- function(x) {
return(mean(x)/length(x) * sum(abs(x^(1/3) - sqrt(median(x)))))
}
perc5 <- median <- perc99 <- vkmeas <- numeric(10000)
for (i in 1:10000) {
bootstrap_sample <- sample(large, replace = T) # bootstrap from large this time
perc5[i] <- quantile(bootstrap_sample, probs = 0.05)
median[i] <- median(bootstrap_sample)
perc99[i] <- quantile(bootstrap_sample, probs = 0.99)
vkmeas[i] <- vkmeasure(bootstrap_sample)
}
par(mfrow = c(2, 2))
hist(perc5, freq = FALSE, axes = FALSE, breaks = 30, xlab = "Height in cm",
ylab = "", main = "Fifth percentile", col = "#1E90FF88", border = "#00008B")
axis(1)
hist(median, freq = FALSE, axes = FALSE, breaks = 30, xlab = "Height in cm",
ylab = "", main = "Median", col = "#1E90FF88", border = "#00008B")
axis(1)
hist(perc99, freq = FALSE, axes = FALSE, breaks = 30, xlab = "Height in cm",
ylab = "", main = "Ninety-ninth percentile", col = "#1E90FF88", border = "#00008B")
axis(1)
hist(vkmeas, freq = FALSE, axes = FALSE, breaks = 30, xlab = "vk units", ylab = "",
main = "van Kesteren measure", col = "#1E90FF88", border = "#00008B")
axis(1)
We have magically done away with a problem - that of distributional assumptions - by pulling ourselves up from our bootstraps, not unlike our friend Baron Munchausen! Fantastic! Or is it?
Of course, there are some downsides to this approach; it is not the magical solution to getting rid of distributional assumptions in any situation. As you can see in the Fifth Percentile graph in the image above, there is some discreteness to the distribution that we do not expect in the actual sampling distribution of the fifth percentile characteristic:
# Sample 10000 times from the ACTUAL population
perc5actual <- numeric(10000)
for (i in 1:10000) {
smp <- sample(pop, 1000)
perc5actual[i] <- quantile(smp, probs = 0.05)
}
# Compare bootstrap to actual sampling distribution
opt <- par(mfrow = c(2, 1), mar = c(4, 4, 0, 4))
hist(perc5, freq = FALSE, xlim = c(166, 171), axes = FALSE, breaks = 30, xlab = "",
ylab = "", main = "", col = "#1E90FF88", border = "#00008B")
mtext(text = "Bootstrap", side = 2)
axis(1)
hist(perc5actual, freq = FALSE, xlim = c(166, 171), axes = FALSE, breaks = 30,
xlab = "Height in cm", ylab = "", main = "", col = "#1E90FF88", border = "#00008B")
mtext(text = "Actual", side = 2)
axis(1)
In this case the bootstrap sampling distribution does not work so well for determining the uncertainty or 95% confidence interval around the statistic of interest. As seen in this figure, the actual sampling distribution looks quite different to that inferred from bootstrap. How would we solve this problem? There are several ways:
The bootstrap is a fantastic means of nonparametrically determining the uncertainty of your estimate, but it should be used with care. Inspect the resulting distribution for discreteness such as in the 5th percentile graph above. And mathematical statistics is not completely obsolete ;)
Source: http://en.citizendium.org/wiki/Image:Dore-Munchausen-pull.jpg↩
Source: https://www.cbs.nl/nl-nl/visualisaties/bevolkingsteller as per the writing of this post.↩
Source: https://is.gd/cbsdata↩
Quick google searchy source: https://www.langzijn.nl/tag/langste-man-nederland↩
this explanation follows a frequentist framework of statistics. For an interesting sidestep and Bayesian credible intervals, do read this paper - http://doi.org/10.3758/s13423-015-0947-8↩
Yes, the source is a wikipedia link: https://en.wikipedia.org/wiki/Bootstrapping_(statistics)#Smoothed_bootstrap↩


Drug dealer arrested at Birmingham Airport jailed over £50k heroin find
Zaoheb Iqbal, 33, was locked up for nine years after admitting conspiracy to supply class A and B drugs
by Stephanie Balloo, https://www.facebook.com/MissBalloo/A drug dealer arrested shortly after stepping off a flight at Birmingham Airport has been jailed after police found almost £50,000-worth of heroin in a car.
Zaoheb Iqbal, from Coventry, had just returned from Pakistan when police made the arrest.
The 33-year-old was first spotted running from Springfield Road, Foleshill in December last year, where officers stopped a Peugeot 307.
The car was found to contain a huge stash of heroin with an estimated street value of £48,000.
The occupants of the car were arrested and charged, but police say officers were set on convicting Iqbal.
Iqbal was arrested, but officers had to release him when a search found he had nothing on him.
But officers then retraced his steps and found a set of keys to a parked car he had been standing next to.
A search then uncovered over £18,000 in cash and two mobile phones in the footwell.
One of the phones was linked to Iqbal and contained records of calls to the driver of the Peugeot.
Further calls linked him to a drugs seizure with a street value of over £50,000 in Villa Road the month before.
Iqbal, from Ransom Road, was arrested at the airport after returning from Pakistan and pleaded guilty at the start of his trial at Birmingham Crown Court on October 28.
He has now been jailed for a total of nine years for conspiracy to supply class A and class B drugs.


I recently had an issue with use_inline_resources.
This feature's documentation is lackluster, and I learnt about its magic thanks to some scraps of information.
I wanted to share some of my info about how it actually works.
The basics
use_inline_resources
is used to separate a LWRP's run context from the main run, making it run in an isolated "mini-run".
Assume the following structure inside cookbook slasher
:
-
resources/default.rb
:# resource definition for slasher LWRP actions :swing default_action :swing
-
providers/default.rb
:# provider for slasher LWRP use_inline_resources action :swing do execute 'echo swish' end
This causes the following effects:
-
You cannot subscribe to / notify resources that are not part of this resource's context.
This will break:# provider for slasher LWRP use_inline_resources action :swing do execute 'echo swish' do notifies :restart,'service[nginx]' # not defined in this LWRP! end end
-
The external resource is automatically "updated" (meaning it triggers other resources using subscribe/notify) whenever one of the resources in the run changes.
This will work:# External usage of slash service nginx slash do notifies :restart,'service[nginx]' # Will happen because the execute resource will "update" end
This behaviour is the encouraged way to implement LWRPs, because it helps encapsulation - they feel like "atomic" resources when used in recipes, and have no need to consider other resources when managing naming, notifications etc., especially other instances of the same resource. It'll probably be enabled by default in Chef13.
The internals
This is the interesting part - how it's actually implemented.
If you'll look at the Chef source (not in master
, where I guess everything changed because it's the default behaviour), under file lib/chef/provider/lwrp_base.rb
, we'll see that the method use_inline_resources
does some mixin magic:
def use_inline_resources
extend InlineResources::ClassMethods
include InlineResources
end
The mixed-in module (in the same file) overrides the method action
(used to define actions in LWRP) with the following code:
def action(name, &block)
define_method("action_#{name}") do
recipe_eval_with_update_check(&block)
end
end
As you can see, it calls recipe_eval_with_update_check
(instead of instance_eval
in the regular version), which will temporarily replace the run context with a new one (with an empty resource collection), run the resource's action, and then inspect the resources defined in this temporary context and see if any of them were updated. If so, it'll mark this resource (the LWRP) as updated too:
(Comments are mine)
def recipe_eval_with_update_check(&block)
saved_run_context = @run_context # Save that for later
temp_run_context = @run_context.dup # Create new run context
@run_context = temp_run_context # Set it as current
@run_context.resource_collection = Chef::ResourceCollection.new # New and empty collection
return_value = instance_eval(&block) # Compile LWRP
Chef::Runner.new(@run_context).converge # Execute compiled LWRP
return_value # Return result
ensure # Always happens, even if we had an error
@run_context = saved_run_context # Restore old run context
if temp_run_context.resource_collection.any? {|r| r.updated? } # Search for modified resources
new_resource.updated_by_last_action(true) # If found, update LWRP
end
end
And that's how it's done!


< Back to home
< Back to previous page
로그인
|
회원가입
|
장바구니
당신에게 마스크가 필요한 이유
|
마스크의 종류
|
마스크의 보호효과 개선법
|
마스크 보관 및 세탁법
|
마스크 구매
MASK SHOP
Advanced protection & lightweight comfort
Best protection & comfort
face covering mask
Dust Full Face Double Filter Gas Mask for Everyone
Breathable Dust Proof Face Mask Protector Cycling
Disposable Face Mask Layer Mouth Masks For Women Men
The 3-layer W95+ washable & reusable face mask
Adjustable And Reusable White Fabric Face Mask
Two layers of 100-percent cotton with adjustable straps and a multi-layer filter
M2 All-Day Anti-Microbial Face Mask
FACE COVERS
Triple-Layer Cloth Pleated Face Masks for Adults


| Home | Trees | Indices | Help |
|
|---|
|
|
A module containing the exception classes for the adldap module. Copyright 2010 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
|
|||
|
Error Generic Error class for adldap. |
|||
|
ObjectPropertyNotFoundError An attempt was made to access a property that was not found. |
|||
|
UserNotDisabledError An attempt was made to enable a user that was not disabled. |
|||
|
UserNotEnabledError An attempt was made to disable a user that was not enabled. |
|||
|
UserNotLockedOutError An attempt was made to unlock a user that is not locked out. |
|||
|
NoComputerPasswordResetError Resetting the password for computer objects is not supported. |
|||
|
LDAPConnectionFailedError The LDAP server could not be contacted. |
|||
|
InvalidCredentialsError The credentials supplied were invalid. |
|||
|
QueryTimeoutError The ldap query timed out waiting for results. |
|||
|
InvalidPropertyFormatError The properties requested for the object are in an invalid format. |
|||
|
ADObjectClassOnlyError These results can only be retrieved when using the ADObject class type. |
|||
|
ADObjectNotFoundError The search returned zero results. |
|||
|
ADDomainNotConnectedError You must call Connect() on the Domain object before this operation. |
|||
|
ADPasswordSetFailedError The attempt to update the password failed. |
|||
|
MemberAlreadyError The group member already exists. |
|||
|
NotAMemberError The object is not a member of the group. |
|||
|
NonListParameterError The parameter must be a list or other iterable. |
|||
|
ServerRefusedOperationError The server refused to perform the operation requested. |
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Tue Feb 01 17:00:01 2011 | http://epydoc.sourceforge.net |


| | |
- RMSE(input_flow, target_flow, mean=True)
- Root mean square error
- conv(batchNorm, in_planes, out_planes, kernel_size=3, stride=1)
- Basic convotion manipulation with or without batchnorm
- crop(input, target)
- Match the dimension of input and target dimension
- deconv(in_planes, out_planes)
- Calculate the flow inference for next level using convolution transpose with ReLU
- predict_flow(in_planes)
- Calculate the current flow inference using convolution transpose
- upRMSE(output, target)
- Root mean square error with upsampling
|


The T-15 is a 3 speed transmission with a cast iron case.
I has a casting number of T15 or 1307 and a 1 1/8" 10
spline input shaft. The T-15 has a 1 3/8" 6 spline output shaft.
It has a reputation as the strongest of the 3 speeds.
|
|
Top view of the T-15.
|
|
|
The casting numbers on the T-15 are on the passenger side near the
top back.
|
|
|
Here's a top view of a T-90 and a T-15. The T-90 has an adapter on
the front for the Dauntless V6, the adapter was probably originally
on a T-86. The front of each transmission is even to show how much
longer the T-15 is compared to the T-90.
|
Usage
The T-15 was used only in V8 equipped CJs and Jeep trucks
from 1972 to 1975.
| Transmission | 1st | 2nd | 3rd | 4th | 5th | Rev |
| T-15 | 3.00 | 1.83 | 1.00 | | | 3.00 |


open fun getAllObjects(): List<Cacheable>
Overrides Cache.getAllObjects
Returns a list of all the cached objects.


Auto-Enrol Workplace Solution AEWS has been designed to be flexible to the differing needs that employers may face whilst tackling auto-enrolment (AE). The system is simple to use but does require an understanding of AE.
AEWS has been designed to help you manage your AE obligations. The responsibility for complying with the regulations will ultimately be yours as an employer. The system will help you but you should expect to have to work closely with your payroll, HR and pension administration teams to make sure that you are compliant.
This guide has been designed to be a simple step by step guide to AEWS, highlighting the various journeys and detailing how the system should form part of your regular process. It can be used in conjunction with the AEWS user guide.


nano
Component-level MacBook repairs
Your Mac doesn't work? It chimes but has a blank display? Got water on it?
An Apple authorized center will charge you 750€ for a new logic board. Most of the times it can be fixed by replacing one small component.
That's what we do at nano.
Bring my Mac back!
PT


Indian IT Minister: Indian iPhone Will Be Exported Abroad - Gizchina.com
by Argam ArtashyanRate this post
As Reuters reported today, Indian IT Minister Ravi Shankar Prasad said that Apple will further expand operations in India.
Particularly, Prasad said that as an Apple component supplier, Salcomp will produce parts for Apple at its Chennai plant in southern India. To this end, Celcom will invest 20 billion rupees (about $278.67 million) in the next five years to produce smartphone chargers and other parts. This move will create about 10,000 jobs for India.
Prasad also said that the Indian iPhone will also be exported to the international market. He expects India’s smartphones and parts export to reach $1.6 billion this year.
How the Indian iPhone Performs?
Previously, there have been some reports published last month. They were saying that Apple’s foundry Foxconn has begun producing iPhone XR in India and will produce the iPhone 11 later. Prior to Foxconn, Wistron had produced old models such as the iPhone 6s, iPhone SE, and iPhone7 for Apple at its Bangalore factory.
Many think that the iPhones produced in India are for this market only. But the truth is that the Indian iPhone is not completely targeted at the Indian market. Apple also plans to export some of the iPhones produced in India to other markets, such as Europe.
By the way, headquartered in Finland, Salcomp is a leading developer and manufacturer of chargers and adapters in Shenzhen, China, Chennai, India, and Manaus, Brazil.
Also Read: Apple Shipped 10 Million iPhones In China In The Past Two Months
In the past, Apple has been producing its iPhones mainly in China. There was a huge market for the Cupertino-based company. But now, when the China-based manufacturers leave no space for the US company, it has to find other markets. In this sense, the Indian market is ideal. And now, it turns out the iPhones made in India will be shipped to the international market.


Login
Create Account
My Interests
Avaliable Properties
News
Back
Login:
Student Number:
Password:
Forgot Password
Log In
OR
Create Account


--- title: call_to_action: Contact background_image_path: large_header: true ---
We know you love your animals, but sometimes it isn't always the easiest to travel with them. Stringent regulations can make it a pain to find pet friendly hotels. We are here to help make your next trip more enjoyable for your fury ones and you.
We work hard to make sure that we take care of all of our guests here at Pugsley's Place LLC. Please notify us of any special needs your pet may have in advance or at the time you drop them off so that we can make their stay as happy as possible.


| Author: | PyBlosxom Development Team |
|---|---|
| Version: | advanced_installation.txt 1042 2007-06-16 04:22:36Z willhelm |
| Copyright: | This document is distributed under the MIT license. |
Contents
We encourage you not to try any of this until you've gotten a blog up and running.
This chapter covers additional advanced things you can do to your blog that will make it nicer. However, they're not necessary and they're advanced and we consider these things to be very much a "you're on your own" kind of issue.
If you ever have problems with PyBlosxom and you ask us questions on the pyblosxom-users or pyblosxom-devel mailing lists, make sure you explicitly state what things you've done from this chapter. It'll go a long way in helping us to help you.
In the default installation, the PyBlosxom script is named pyblosxom.cgi.
For a typical user on an Apache installation with user folders turned on, PyBlosxom URLs could look like this:
http://www.joe.com/~joe/cgi-bin/pyblosxom.cgi http://www.joe.com/~joe/cgi-bin/pyblosxom.cgi/an_entry.html http://www.joe.com/~joe/cgi-bin/pyblosxom.cgi/programming/another_entry.html
That gets pretty long and it's not very good looking. For example, telling the URL to your mother or best friend over the phone would be challenging. It would be nice if we could shorten and simplify it.
So, we have some options:
Both methods are described here in more detail.
There's no reason that pyblosxom.cgi has to be named pyblosxom.cgi. Let's try changing it from pyblosxom.cgi to blog. Now our example URLs look like this:
http://www.joe.com/~joe/cgi-bin/blog http://www.joe.com/~joe/cgi-bin/blog/an_entry.html http://www.joe.com/~joe/cgi-bin/blog/category1/another_entry.html
That's better looking in the example. In your specific circumstances, that may be all you need.
You might have to change the base_url property in your config.py file to match the new URL.
Note
A note about the base_url:
The base_url property should NOT have a trailing slash.
If you're running on Apache, you might have to tell Apache that this is a CGI script even if it doesn't have a .cgi at the end of it. If you can use .htaccess files to override Apache settings, you might be able to do something like this:
# this allows execution of CGI scripts in this directory Options ExecCGI # if the user doesn't specify a file, then instead of doing the # regular directory listing, we look at "blog" (which is our # pyblosxom.cgi script renamed) DirectoryIndex blog # this tells Apache that even though "blog" doesn't end in .cgi, # it is in fact a CGI script and should be treated as such <Files blog> ForceType application/cgi-script SetHandler cgi-script </Files>
You may need to stop and restart Apache for your Apache changes to take effect.
Apache has a module for URL rewriting which allows you to convert incoming URLs to other URLs that can be handled internally. You can do URL rewriting based on all sorts of things. See the Apache manual for more details.
In our case, we want all incoming URLs pointing to blog to get rewritten to cgi-bin/pyblosxom.cgi so they can be handled by PyBlosxom. Then all our URLs will look like this:
http://www.joe.com/~joe/blog http://www.joe.com/~joe/blog/an_entry.html http://www.joe.com/~joe/blog/category1/another_entry.html
To do this, we create an .htaccess file (it has to be named exactly that) in our public_html directory (or wherever it is that /~joe/ points to). In that file we have the following code:
RewriteEngine on RewriteRule ^blog?(.*)$ /~joe/cgi-bin/pyblosxom.cgi$1 [last]
The first line turns on the Apache mod_rewrite engine so that it will rewrite URLs.
The second line has four parts. The first part denotes the line as a RewriteRule. The second part states the regular expression that matches the part of the URL that we want to rewrite. The third part denotes what we're rewriting the URL to. The fourth part states that after this rule is applied, no future rewrite rules should be applied.
If you do URL rewriting, you may have to set the base_url property in your config.py accordingly. In the above example, the base_url would be http://www.joe.com/~joe/blog with no trailing slash.
For more information on URL re-writing, see the Apache documentation (1.3, 2.0, 2.2).


By default the table component is setup for client side
data manipulation. What if there is too much data to send
to the front end? Implementing server-side data manipulation
is what is required.
For server-side integration to work properly, the following must be present on go-table:
(tableChange)
- to handle the table events[loadingData]
- to handle the loading of the table[tableConfig]
- because it's required
There are 5 properties of the table config that are important when building out server-side integration:
pageConfig.offset
- the current place in the data setpageConfig.perPage
- the current number of items on each pagesearchConfig.searchTerm
- the current search term (if table search has value)sortConfig.column
- the current column that is sorted (if table is sorted)sortConfig.direction
- the current sort direction (if table is sorted)
It is recommended to pass the entire GoTableConfig
to the service that is retrieving the data and map
the properties of the object to the corresponding
parameters of the endpoint that is being hit.
When the data is successfully returned, the properties shown below must be set.
For the best user experience with server-side integrations, the data returned from the server should have two properties:
These properties should then be set, upon a successful response,
to the corresponding properties on the GoTableConfig
,
tableData
and totalCount
.
When server mode is enabled, this property will be set to
true
whenever the
tableChange
event
is fired. The responsibility to set it back to
false
falls upon
on the parent component after data is received from the server.
This is to provide a consistent and helpful experience to
users and should not be overridden.
The tableChange
event is emitted anytime a trigger is fired in the table
component. These triggers are:


Choose a sector
Information collected through this form is used to improve this website.
Any information you submit that could identify you (e.g. name, email address) will be stored securely, and destroyed after we process your feedback.
We want this information to be the best it can be and we know we can’t do it without you. Let us know what you thought of this page and what other information you would like to see.
We do not reply to feedback. Contact us if you need a response.