🤙 Javascrip & The Dom 🤙
HTML vs CSS
HTML & CSS are the backend components which make up a static (Non-Interactive) website. I am going to attempt to explain the concept using the analogy of building a home:
Imagine you want to build a home, where do you start? Well you would start with a foundation, followed by framing, then a roof, then the facade, and so on until you have the bones of a house. The house is now standing and weathertight but without any features or decorations (i.e colours, furnishings etc).
Similar to using concrete and timber for the foundation and structure of a house, we use HTML to create the foundation and structure of our website.
Now that we have a house(building), how do we turn that into a home? Well we would add features and decorations (i.e colours, furnishings, carpet, window hangings etc).. We have now turned a house into a HOME.
Similar to using paint, carpet, furnishings .ect to personalise our house into a home, we use CSS to decorate our website making it more personalised and easier on the eye.
Control Flow & Loops
In Javascript the control flow is the default way in which our computer or browser executes statements in a script. I.E from first to last; however, sometimes we may need to interupt the control flow in order to create the correct behaviour or function for a particular input. How can we do this? With Loops.
A great example of a loop is a 'do/while' loop, which loops through a block of code while a specified condition remains true. This can be handy when we are trying to interupt the normal control flow to repeat a task a certain number of times, i.e increment a number, make a function repeat it's output.
We can liken the control flow to tasks which we perform in every day life, I am a keen golfer ⛳ so will use an example from on the course. Personally i have a set routine before every shot, which involves:
- Gauging the distance
- Selecting a club
- Visualizing the shot
- 2x practice swings
- Address the ball
- Clear my head
- Hit the ball out of bounds 🏌
Sometimes i need to repeat one of the steps in my process due to a distraction or to make sure i have the right club in hand. Imagine for example i had already picked my club but then the wind started gusting an extra 20kmph, i would want to start my process again right? Well if life worked like the control flow, we couldn't start any process again and i would be stuck trying to hit the wrong club; Luckily we have control over our process by using our freewill, in Java we use loops to interupt the normal flow and assert our freewill.
The DOM
Not to be confused with THE DON!
We talked earlier about HTML & CSS(The static components of a website), and Java being what allows us to implement interactivity to our website. Well the DOM (Document Object Model) is the glue which puts them both together. The DOM is part of the overall structure of our webpage sitting above the HTML, but below the window object, anything that goes on below it in the hierarchy can be seen/accessed. Take a look at the pic below which illustrates this better:
THE DOM is the gateway to all of the HTML elements which make up what is displayed in our browser, it provides the missing link which ties HTML and CSS with JavaScript.
Arrays & Objects
It is better to start by explaining what an object is. An object is the most powerful data type in Java as they are very widely used, an object is defined and can store multiple values, check out the object below:
We can access the data in the object by referencing it using the object name 'golfer' and the value we want returned, in this case 'handicap', which will return a value of 8.
How about Arrays? Well an array is similar to an object, except we are storing all the values within a list rather than individual values, check out the array below:
As you can see, to access an item in an array we must refernce the object first "golfClubs", then use bracket notation to return the value we wish to see "[1]", which in this example will return a value of '8 Iron'.... "But shouldn't that return a value of 'Seven Iron'?" I hear you ask... Well not with Arrays, the first item in the array is always [0].. Don't ask, just trust me on this one!
Functions
Functions are like mini-programs that we can use in Java to perform a particular task, either under the normal control flow, or if certain conditions are met.
The principle of functions is that they can be called on multiple times which saves us the effort of re-writing code throughout a project. Functions help us to make our code more concise by drastically cutting down the amount of code we need to write in order to perform a task, this makes our code easier to examine and debug when required.


We're sorry but vuerd-firebase doesn't work properly without JavaScript enabled. Please enable it to continue.


|
ICEfaces ACE Components 3.3.0 Java API Documentation |
||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
| Interface Summary | |
|---|---|
| IGMap | |
| IGMapAutocomplete | |
| IGMapControl | |
| IGMapEvent | |
| IGMapInfoWindow | |
| IGMapLayer | |
| IGMapMarker | |
| IGMapOverlay | |
| IGMapServices |
| Class Summary | |
|---|---|
| GMap | |
| GMapAutocomplete | |
| GMapAutocompleteBase | An Icesoft implementation of Google's Places autocomplete tool. |
| GMapAutocompleteRenderer | |
| GMapAutocompleteTag | |
| GMapBase | The base component for the ACE gMap (Google Maps API) set of components. |
| GMapControl | |
| GMapControlBase | The ace:gMapControl component serves as an easy interface to modify the position, style and rendered state of the controls that appear on the ace:gMap that this tag is nested within. |
| GMapControlRenderer | |
| GMapControlTag | |
| GMapEvent | |
| GMapEventBase | The ace:gMapEvent component allows the other Google maps subcomponents to integrate with the google event handling API and execute user defined code. |
| GMapEventRenderer | |
| GMapEventTag | |
| GMapInfoWindow | |
| GMapInfoWindowBase | The ace:gMapInfoWindow component creates a pop-up window within the parent ace:gMap, which can be used to display either text via the 'content' attribute or nested html or jsf tags. |
| GMapInfoWindowRenderer | |
| GMapInfoWindowTag | |
| GMapLayer | |
| GMapLayerBase | The ace:gMapLayer component creates one of a variety of layers on top of the parent ace:gMap, to enhance or display new information. |
| GMapLayerRenderer | |
| GMapLayerTag | |
| GMapMarker | |
| GMapMarkerBase | The ace:gMapMarker component places one of Google's markers upon the given latitude/longitude coordinates of the parent ace:gMap. |
| GMapMarkerRenderer | |
| GMapMarkerTag | |
| GMapOverlay | |
| GMapOverlayBase | The ace:gMapOverlay component allows for the creation of user defined shapes on the parent ace:gMap. |
| GMapOverlayRenderer | |
| GMapOverlayTag | |
| GMapRenderer | |
| GMapResourceHandler | |
| GMapServices | |
| GMapServicesBase | The ace:gMapServices tag allows access to the various 'services' that Google provides through its maps API. |
| GMapServicesRenderer | |
| GMapServicesTag | |
| GMapTag |
|
ICEfaces ACE Components 3.3.0 Java API Documentation |
||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Scene Viewer
Scenes
Models
Texture
Colors
Arch
Scans
Scene Hierarchy
BVH
Scene Generator Config
Scene Description
Please enter an textual description of your scene and
click "Create" to create a scene based on your description
Scene Template
Load
Instructions
Loading Model...


class: middle # Behaviour Driven Development with PHP, Behat, and Mink (Featuring Docker! 🐳) --- class: middle ## Some questions to answer * What is BDD, how is it different from TDD? * What is a unit test. How is it different from a "functional test"? * When should I use BDD? * What are the tradeoffs? What do I sacrifice by going BDD? --- class: middle ## Core Concepts * Context-Action-Outcome pattern * Gherkin/Cucumber "language" & `.feature` files * BDD Framework / Assertion Library (PHPUnit) / Web Functionality (Mink) * Choice of WebDrivers --- class: middle ## Overview * How can I get started with BDD? * Writing our first `.feature` file. * Generating context files & appending step definitions * Including asserts * Including "Mink", and Configuring WebDrivers * Definition list * Test web-facing features * Running behat in a CI environment --- class: middle ## What is BDD, and how is it different than TDD? **BDD** — **B**ehaviour **D**riven **D**evelopment. **TDD** — **T**est **D**riven **D**evelopment. When you put the two terms side-by-side like that, they don't seem very distinct, do they? ??? Tests in the BDD paradigm are "Black Box" tests; they're high-level. Broadly speaking, they don't make any assumptions about the inner workings of the application. Tests in the TDD paradigm usually imply unit-tests, or "Clear Box" tests; they might isolate a class or a method for testing. (Something that a user would have no knowledge of). --- ## Black Box Testing * Tests input and output *at the application level* * For this reason, tests are close to application specs * Assumes no knowledge of __how__ results are generated ![Black Box](./black-box.png) --- ## White Box Testing * Tests assume knowledge of modules/units inside an application * Classes can be tested in isolation * Generates greater code coverage ![White Box](./white-box.png) --- class: middle BDD & TDD are philosophies, rather than sets of tools. You can "do BDD" with PHPUnit, and you can "do TDD" with Behat. The borders between these tools & concepts are somewhat porous! --- class: middle ## Why Should I Use Behat/BDD for testing my PHP application? 1. Fun, informative workflow! 2. Share terse, unambiguous, functional, and human-readable specifications. * Clients and non-technical colleagues will love it.. 3. Lets you write specs through the user's eyes * this often reveals assumptions sooner than they would otherwise be seen. ??? Additionally – it can be used to test things like how your application integrates a 3rd party library or package. I.e., does your auth system work properly *at a browser* level? Behat is also not some alpha-0.2, just-in-it-for-the-github-stars-vapourware. It's been around since 2011, and while it doesn't have the 11k GitHub stars that PHPUnit has, 2.7k is nothing to shake a stick at, either! --- class: middle ## When Would I Be Better off with TDD and/or PHPUnit? Rule of thumb - BDD is for user-level testing. Can be great for smoke-tests, It also provides a nice bridge for communicating specs w/ client. Use TDD/Unit-testing for libraries you plan to reuse, and when you want to ensure code coverage. When developers are your client or stakeholder, they'll probably appreciate your unit tests, rather than application-level tests. --- class: center, middle ### Demo time!
--- class: middle # Behat Quickstart/Overview * Create a brand new project w/ composer. * Require Behat & configure it to do some very basic hello world testing. * Install & base configuration of Mink * Why Mink? What's it Do? WebDrivers? Whaat? * Check out the new output of behat -dl * Require selenium and control the browser to test some JS, then, too! [https://dannorth.net/whats-in-a-story/](https://dannorth.net/whats-in-a-story/) [https://dannorth.net/introducing-bdd/](https://dannorth.net/whats-in-a-story/) --- class: middle ## Create new project ```bash composer init composer require --dev behat/behat vendor/bin/behat --init ``` --- class: middle ### Create a contrived example about math. Create a `math.feature` file, and test some basics. ```gherkin When I add "1" and "2" Then the result should equal "3" ``` implement `Behat\Behat\Context\SnippetAcceptingContext` Run `behat` and append the step definitions. Fail, update FeatureContext.php until it works! --- class: middle ### Parsing, and what's what. Gherkin = the language we're seeing in the `.feature` files. The class `Behat\Gherkin` is an implementation of the gherkin language. Behat is the thing that matches parses gherkin steps and maps them to executable methods in a `FeatureContext` file. > Behat does not differentiate between step keywords when matching regular expressions to methods. So a step defined with @When could also be matched to `@Given` ..., `@Then` ..., `@And` ..., `@But` ..., etc. (http://docs.behat.org/en/v2.5/guides/2.definitions.html) --- class: middle ### Refactor to use some proper asserts ```bash composer require --dev phpunit/phpunit ``` ```php use PHPUnit\Framework\Assert as Assertions ``` `Assertions::assertTrue, ::assertEquals` --- class: middle ## Install Mink So far, it probably looks like we've shown an alternative boilerplate to the regular PHPUnit config - we've just been asserting things slightly differently. Let's dig a little deeper into the Behaviour Driven part of BDD. It's time to install Mink - a browser controller. [http://mink.behat.org/en/latest/at-a-glance.html](http://mink.behat.org/en/latest/at-a-glance.html) ```bash composer require --dev behat/mink behat/mink-goutte-driver behat/mink-extension ``` (Examine the 'suggests installing' parts of composer output) --- class: middle ## Configure, and extend our earlier class ```bash ./vendor/bin/behat -dl ``` Definition list is still the same as before. Better configure it! --- ### Hold on, I don't have any Context for this http://behat.org/en/latest/user_guide/context.html#multiple-contexts > Your context class is initialized before each scenario is run, and every scenario has its very own context instance. This means 2 things: > 1. Every scenario is isolated from each other scenario’s context. You can do almost anything inside your scenario context instance without the fear of affecting other scenarios - every scenario gets its own context instance. > 2. Every step in a single scenario is executed inside a common context instance. This means you can set private instance variables inside your `@Given` steps and you’ll be able to read their new values inside your `@When` and `@Then` steps. --- class: middle Make a `behat.yml` file to configure, and test what definitions we have: ```yaml # behat.yml default: suites: default: contexts: - FeatureContext extensions: Behat\MinkExtension: base_url: ~ sessions: # can be specified via @session_name annotations in .feature files! default: goutte: ~ ``` And, extend our base context: ```php class FeatureContext extends MinkContext ``` --- class: middle, center # Let's goooo(gle)
```bash ./vendor/bin/behat -dl ``` --- # Select some elements, and submit some forms ```gherkin Given I go to "http://google.com" When I fill in "Search" with "Test" And I press "Google Search" ``` ### Examine the source of fill in "" with "" definition ```bash vendor/behat/mink-extension/src/Behat/MinkExtension/Context/MinkContext.php:121 vendor/behat/mink/src/Element/TraversableElement.php:152 vendor/behat/mink/src/Selector/NamedSelector.php ``` --- class: middle ### Headless/Head-ed browsers From our more trivial selection above, we might also want to see autocomplete. For that, we can't use a headless browser like Goutte. We'll need a full on browser emulator to parse the JavaScript! ```bash composer require --dev behat/mink-selenium2-driver brew install selenium-server-standalone chromedriver ifconfig | grep inet ``` ```yaml # behat.yml # ... selenium2: wd_host: http://{host-machine-network-ip}:4444/wd/hub capabilities: # required by mink-extension 2.3 marionette: null browserName: chrome browser: chrome sessions: # ... javascript: selenium2: ~ ``` Test the autocomplete of DuckDuckGo. ??? ```php /** * @When I wait to see if autocomplete contains :words */ public function iWaitToSeeWords($words) { $this->getSession()->wait( 5000, "document.querySelectorAll('.search__autocomplete').length" ); Assertions::assertContains( $words, $this->getSession()->evaluateScript("document.querySelectorAll('.search__autocomplete')[0].innerText") ); } ``` --- # Let's See the BDD Methodology in Action! New app. Let's make a really cool site where you can share what you ate for breakfast in 140 characters or less! ```bash symfony new chirp.ly lts mv behat.yml chirp.ly/ && mv -f features/ chirp.ly/features mv ./bin/docker chirp.ly/bin ``` ??? * Edit .gitignore * Remove that block from `app_dev.php` that disallows localhost. * Update `behat.yml` to put the `app_dev.php` into the `base_url` `composer update` --- class: middle ## First Test ```gherkin Feature: Does it turn on? In order to "Smoke Test" the application As a Developer I need to be able to confirm that predicable text is served on the homepage. Scenario: Visiting Homepage Given I am on the homepage Then the response status code should be 200 And I should see text matching "Your application is now ready." ``` --- class: middle ## Adding a Feature Okay – let's start with the bare minimum: ```gherkin Feature: Post a chirp In order to tell the world my thoughts As an anonymous user I need to be able to post to chirp.ly Scenario: Finding "new chirp" page Given I am on the homepage Then I should see a "Post Chirp" element When I follow "Post Chirp" And the response status code should be 200 Then the url should match "/app_dev.php/chirp/new" And I should see a "textarea" element ``` ??? ```bash php bin/console doctrine:generate:entity AppBundle:Chirp php bin/console d:s:u -f php bin/console doctrine:generate:crud AppBundle:Chirp ``` --- ```gherkin Feature: Post a chirp In order to tell the world my thoughts As an anonymous user I need to be able to post to chirp.ly Scenario: Navigating to the "new chirp" page Given I am on the homepage Then I should see a "a#post-chirp" element When I follow "Post Chirp" And the response status code should be 200 Then the url should match "/chirp/new" And I should see a "textarea" element And print current URL Scenario: Making a new chirp Given I am on "/chirp/new" And I fill in the following: | Body | I am really loving this site!!! | And I press "Create" And the response status code should be 200 Then the url should match "/chirp/\d+" And I should see "I am really loving this site!!!" ``` --- ## API profile vs. User profile ### Testing Glossary - White Box Testing (Structural testing) - TDD - Unit Tests - Black Box Testing (Functional Testing) - BDD - Functional Tests ---


| [ Team LiB ] |
5.2 New-Style Classes and InstancesMost of what I have covered so far in this chapter also holds for the new-style object model introduced in Python 2.2. New-style classes and instances are first-class objects just like classic ones, both can have arbitrary attributes, you call a class to create an instance of the class, and so on. In this section, I'm going to cover the few differences between the new-style and classic object models. In Python 2.2 and 2.3, a class is new-style if it inherits from built-in type object directly or indirectly (i.e., if it subclasses any built-in type, such as list, dict, file, object, and so on). In Python 2.1 and earlier, a class cannot inherit from a built-in type, and built-in type object does not exist. In Section 5.4 later in this chapter, I cover other ways to make a class new-style, ways that you can use in Python 2.2 or later whether a class has superclasses or not. As I said at the beginning of this chapter, I suggest you get into the habit of using new-style classes when you program in Python 2.2 or later. The new-style object model has small but measurable advantages, and there are practically no compensating disadvantages. It's simpler just to stick to the new-style object model, rather than try to decide which model to use each time you code a new class. 5.2.1 The Built-in object TypeAs of Python 2.2, the built-in object type is the ancestor of all built-in types and new-style classes. The object type defines some special methods (as documented in Section 5.3 later in this chapter) that implement the default semantics of objects:
A subclass of object may override any of these methods and/or add others. 5.2.2 Class-Level MethodsThe new-style object model allows two kinds of class-level methods that do not exist in the classic object model: static methods and class methods. Class-level methods exist only in Python 2.2 and later, but in these versions you can also have such methods in classic classes. This is the only feature of the new-style object model that is also fully functional with classic classes in Python 2.2 and later. <IP_ADDRESS> Static methodsA static method is a method that you can call on a class, or on any instance of the class, without the special behavior and constraints of ordinary methods, bound and unbound, on the first argument. A static method may have any signature: it may have no arguments, and the first argument, if any, plays no special role. You can think of a static method as an ordinary function that you're able to call normally, despite the fact that it happens to be bound to a class attribute. While it is never necessary to define static methods (you could always define a function instead), some programmers consider them to be an elegant alternative to such functions whose purpose is tightly bound to some specific class. You build a static method by calling built-in type staticmethod and binding its result to a class attribute. Like all binding of class attributes, this is normally done in the body of the class, but you may also choose to perform it elsewhere. The only argument to staticmethod is the function to invoke when Python calls the static method. The following example shows how to define and call a static method: class AClass(object): def astatic( ): print 'a static method' astatic = staticmethod(astatic) anInstance = AClass( ) AClass.astatic( ) # prints: a static method anInstance.astatic( ) # prints: a static method This example uses the same name for the function passed to staticmethod and for the attribute bound to staticmethod's result. This style is not mandatory, but it's a good idea, and I recommend that you use it. <IP_ADDRESS> Class methodsA class method is a method that you can call on a class or on any instance of the class. Python binds the method's first argument to the class on which you call the method, or the class of the instance on which you call the method; it does not bind it to the instance, as for normal bound methods. There is no equivalent of unbound methods for class methods. The first formal argument of a class method is conventionally named cls. While it is never necessary to define class methods (you could always alternatively define a function that takes the class object as its first argument), some programmers consider them to be an elegant alternative to such functions. You build a class method by calling built-in type classmethod and binding its result to a class attribute. Like all binding of class attributes, this is normally done in the body of the class, but you may also choose to perform it elsewhere. The only argument to classmethod is the function to invoke when Python calls the class method. Here's how to define and call a class method: class ABase(object): def aclassmet(cls): print 'a class method for', cls._ _name_ _ aclassmet = classmethod(aclassmet) class ADeriv(ABase): pass bInstance = ABase( ) dInstance = ADeriv( ) ABase.aclassmet( ) # prints: a class method for ABase bInstance.aclassmet( ) # prints: a class method for ABase ADeriv.aclassmet( ) # prints: a class method for ADeriv dInstance.aclassmet( ) # prints: a class method for ADeriv This example uses the same name for the function passed to classmethod and for the attribute bound to classmethod's result. This style is not mandatory, but it's a good idea, and I recommend that you use it. 5.2.3 New-Style ClassesAll features of classic classes, covered earlier in this chapter, also apply to new-style classes. New-style classes also have some additional features with regard to the _ _init_ _ special method, and they all have a _ _new_ _ static method. <IP_ADDRESS> _ _init_ _A new-style class C that inherits _ _init_ _ from object without overriding it lets you pass arbitrary arguments when you call C, but ignores all of those arguments. This behavior can be somewhat surprising.  For example: class C(object): def _ _init_ _(self): pass # rest of class body omitted Now instantiating C( ) without arguments works, but mistakenly trying to pass an argument (e.g., C('xyz')) raises an exception. If class C did not override _ _init_ _, a call C('xyz') would silently ignore the erroneous argument. It's generally best not to silently ignore errors. <IP_ADDRESS> _ _new_ _Each new-style class has a static method named _ _new_ _. When you call C(*args,**kwds) to create a new instance of a new-style class C, Python invokes C._ _new_ _(C,*args,**kwds). Python uses _ _new_ _'s return value x as the newly created instance. Then, Python calls C._ _init_ _(x,*args,**kwds), but only when x is indeed an instance of C (otherwise, x's state is as _ _new_ _ had left it). Thus, for a new-style class C, the statement x=C(23) is equivalent to the following code: x = C._ _new_ _(C, 23) if isinstance(x, C): C._ _init_ _(x, 23) object._ _new_ _ creates a new, uninitialized instance of the class it receives as its first argument, and ignores any other arguments. When you override _ _new_ _ within the class body, you do not need to add _ _new_ _=staticmethod(_ _new_ _), as you normally would: Python recognizes the name _ _new_ _ and treats it specially in this context. In those rare cases in which you rebind C._ _new_ _ later, outside the body of class C, you do need to use C._ _new_ _=staticmethod(whatever). _ _new_ _ has most of the flexibility of a factory function, as covered earlier in this chapter. _ _new_ _ may choose to return an existing instance or to make a new one, as appropriate. When _ _new_ _ does need to create a new instance, it most often delegates creation by calling object._ _new_ _ or the _ _new_ _ method of another built-in type that is a superclass of C. The following example shows how to override static method _ _new_ _ in order to implement a version of the Singleton design pattern: class Singleton(object): _singletons = { } def _ _new_ _(cls, *args, **kwds): if not cls._singletons.has_key(cls): cls._singletons[cls] = object._ _new_ _(cls) return cls._singletons[cls] Any subclass of Singleton (that does not further override _ _new_ _) has exactly one instance. If the subclass defines an _ _init_ _ method, the subclass must ensure its _ _init_ _ is safe when called repeatedly (at each creation request) on the one and only class instance. 5.2.4 New-Style InstancesAll features of instances of classic classes, covered earlier in this chapter, also apply to instances of new-style classes. In addition, new-style classes may define attributes called properties and a special attribute named _ _slots_ _ that affects access to instance attributes. The new-style object model also adds a special method _ _getattribute_ _ that is more general than the _ _getattr_ _ special method present in both the classic and new-style object models. It also has different semantics for per-instance definition of special methods. <IP_ADDRESS> PropertiesA property is an instance attribute with special functionality. You reference, bind, or unbind the attribute with the normal syntax (e.g., print x.prop, x.prop=23, del x.prop). However, rather than following the usual semantics for attribute reference, binding, and unbinding, these accesses call methods on instance x that you specify when defining the property using the built-in type property. Here's how to define a read-only property: class Rectangle(object): def _ _init_ _(self, width, heigth): self.width = width self.heigth = heigth def getArea(self): return self.width * self.heigth area = property(getArea, doc='area of the rectangle') Each instance r of class Rectangle has a synthetic read-only attribute r.area, computed on the fly in method r.getArea( ) by multiplying the sides of the rectangle. The docstring Rectangle.area._ _doc_ _ is 'area of the rectangle'. The property is read-only (attempts to rebind or unbind it fail) because we only specify a get method in the call to property. Properties perform tasks that are similar to those of special methods _ _getattr_ _, _ _setattr_ _, and _ _delattr_ _ (covered in Section 5.3 later in this chapter), but in a faster and simpler way. You build a property by calling built-in type property and binding its result to a class attribute. Like all binding of class attributes, this is normally done in the body of the class, but you may also choose to perform it elsewhere. Within the body of a class C, use the following syntax: attrib = property(fget=None, fset=None, fdel=None, doc=None) When x is an instance of C and you reference x.attrib, Python calls on x the method you passed as argument fget to the property constructor, without arguments. When you assign x.attrib = value, Python calls the method you passed as argument fset, with value as the only argument. When you perform del x.attrib, Python calls the method you passed as argument fdel, without arguments. Python uses the argument you passed as doc as the docstring of the attribute. All arguments to property are optional. When an argument is missing, the corresponding operation is forbidden. For example, in the Rectangle example, we made property area read-only, because we passed only argument fget, not arguments fset and fdel. To obtain similar results for a classic class in Python 2.1, we need to define special methods _ _getattr_ _ and _ _setattr_ _ and in each of them test for attribute name 'area' and handle it specifically. The following example shows how to simulate a read-only property in Python 2.1: class Rectangle: def _ _init_ _(self, width, heigth): self.width = width self.heigth = heigth def getArea(self): return self.width * self.heigth def _ _getattr_ _(self, name): if name= ='area': return self.getArea( ) raise AttributeError, name def _ _setattr_ _(self, name, value): if name= ='area': raise AttributeError, "can't bind attribute" self._ _dict_ _[name] = value <IP_ADDRESS> _ _slots_ _Normally, each instance object x of any class C has a dictionary x._ _dict_ _ that Python uses to let you bind arbitrary attributes on x. To save some memory (at the cost of letting x have only a predefined set of attribute names), you can define in class C a class attribute named _ _slots_ _, which is a sequence (normally a tuple) of strings (normally identifiers).When class C has an attribute _ _slots_ _, a direct instance x of class C has no x._ _dict_ _, and any attempt to bind on x any attribute whose name is not in C._ _slots_ _ raises an exception. Using _ _slots_ _ lets you reduce memory consumption for small instance objects that can do without the ability to have arbitrarily named attributes. Note that _ _slots_ _ is worth adding only to classes that can have so many instances that saving a few tens of bytes per instance is important—typically classes that can have millions, not mere thousands, of instances alive at the same time. Unlike most other class attributes, _ _slots_ _ works as I've just described only if some statement in the class body binds it as a class attribute. Any later alteration, rebinding, or unbinding of _ _slots_ _ has no effect, nor does inheriting _ _slots_ _ from a base class. Here's how to add _ _slots_ _ to the Rectangle class defined earlier, to get smaller (though less flexible) instances: class OptimizedRectangle(Rectangle): _ _slots_ _ = 'width', 'heigth' We do not need to define a slot for the area property. _ _slots_ _ does not constrain properties, only ordinary instance attributes—the attributes that would reside in the instance's _ _dict_ _ if _ _slots_ _ wasn't defined. <IP_ADDRESS> _ _getattribute_ _All references to instance attributes for new-style instances proceed through special method _ _getattribute_ _. This method is supplied by base class object, where it implements all the details of object attribute reference semantics as documented earlier in this chapter. However, you may override _ _getattribute_ _ for special purposes, such as hiding inherited class attributes (e.g., methods) for your subclass's instances. The following example shows one way to implement a list without append in the new-style object model: class listNoAppend(list): def _ _getattribute_ _(self, name): if name = = 'append': raise AttributeError, name return list._ _getattribute_ _(self, name) An instance x of class listNoAppend is almost indistinguishable from a built-in list object, except that performance is substantially worse, and any reference to x.append raises an exception. The following example shows how to implement _ _getattr_ _, _ _setattr_ _, and _ _delattr_ _ so that _ _getattr_ _ is called on every attribute reference, just like _ _getattribute_ _ is for new-style instances: class AttributeWatcher: def _ _init_ _(self): # note the caution to avoid triggering _ _setattr_ _, and the # emulation of Python's name-mangling for a private attribute self._ _dict_ _['_AttributeWatcher_ _mydict']={ } def _ _getattr_ _(self, name): # as well as tracing every call, for demonstration purposes we # also fake "having" any requested attribute, EXCEPT special # methods (_ _getattr_ _ is also invoked to ask for them: check by # trying a few operations on an AttributeWatcher instance). print "getattr", name try: return self._ _mydict[name] except KeyError: if name.startswith('_ _') and name.endswith('_ _'): raise AttributeError, name else: return 'fake_'+name def _ _setattr_ _(self, name, value): print "setattr", name, value self._ _mydict[name] = value def _ _delattr_ _(self, name): print "delattr", name try: del self._ _mydict[name] except KeyError: pass <IP_ADDRESS> Per-instance methodsBoth the classic and new-style object models allow an instance to have instance-specific bindings for all attributes, including callable attributes (methods). For a method, just like for any other attribute, an instance-specific binding hides a class-level binding: attribute lookup does not even look at the class if it finds a binding directly in the instance. In both object models, an instance-specific binding for a callable attribute does not perform any of the transformations detailed in Section 5.1.5 earlier in this chapter. In other words, the attribute reference returns exactly the same callable object that was earlier bound directly to the instance attribute. Classic and new-style object models do differ on per-instance binding of the special methods that Python invokes implicitly as a result of various operations, as covered in Section 5.3 later in this chapter. In the classic object model, an instance may usefully override a special method, and Python uses the per-instance binding even when invoking the method implicitly. In the new-style object model, implicit use of special methods always relies on the class-level binding of the special method, if any. The following code shows this difference between classic and new-style object models: def fakeGetItem(idx): return idx class Classic: pass c = Classic( ) c._ _getitem_ _ = fakeGetItem print c[23] # prints: 23 class NewStyle(object): pass n = NewStyle( ) n._ _getitem_ _ = fakeGetItem print n[23] # results in: # Traceback (most recent call last): # File "<stdin>", line 1, in ? # TypeError: unindexable object The semantics of the classic object model in this regard are sometimes handy for tricky and somewhat obscure purposes. However, the new-style object model's approach regularizes and simplifies the relationship between classes and metaclasses, covered in Section 5.4 later in this chapter. 5.2.5 Inheritance in the New-Style Object ModelIn the new-style object model, inheritance works similarly to the way it works in the classic object model. One key difference is that a new-style class can inherit from a built-in type. The new-style object model, like the classic one, supports multiple inheritance. However, a class may directly or indirectly subclass multiple built-in types only if those types are specifically designed to allow this level of mutual compatibility. Python does not support unconstrained inheritance from multiple arbitrary built-in types. Normally, a new-style class only subclasses at most one substantial built-in type; this means at most one built-in type in addition to object, which is the superclass of all built-in types and new-style classes and imposes no constraints on multiple inheritance. <IP_ADDRESS> Method resolution orderIn the classic object model, method and attribute lookup (also called resolution order) among direct and indirect base classes proceeds left-first, depth-first. While very simple, this rule may produce undesired results when multiple base classes inherit from the same common base class and override different subsets of the common base class's methods; in this case, the overrides of the rightmost base class are hidden in the lookup. For example, if A subclasses B and C in that order, and B and C each subclass D, the classic lookup proceeds in the conceptual order A, B, D, C, D. Since Python looks up D before C, any method defined in class D, even if class C overrides it, is therefore found only in the base class D version. This issue causes few practical problems only because such an inheritance pattern, also known as a diamond-shaped inheritance graph, is rarely used in the classic Python object model. In the new-style object model, however, all types directly or indirectly subclass object. Therefore, any multiple inheritance gives diamond-shaped inheritance graphs, and the classic resolution order would often produce problems. Python's new-style object model changes the resolution order by leaving in the lookup sequence only the rightmost occurrence of any given class. Using the example from the previous paragraph, when class D is new-style (e.g., D directly subclasses object), the resolution order for class A becomes A, B, C, D, object, and no anomalies arise. Figure 5-1 shows the classic and new-style method resolution orders for the case of a diamond-shaped inheritance graph. Figure 5-1. Classic and new-style method resolution orderEach new-style class and built-in type has a special read-only class attribute called _ _mro_ _, which is the tuple of types used for method resolution, in order. You can reference _ _mro_ _ only on classes, not on instances, and, since _ _mro_ _ is a read-only attribute, you cannot rebind or unbind it. <IP_ADDRESS> Cooperative superclass method callingAs we saw earlier in this chapter, when a subclass overrides a method, the overriding method often wants to delegate part of its operation to the superclass's implementation of the same method. The simple solution that is idiomatic in Python's classic object model (calling the superclass's version directly with unbound method syntax) is imperfect in cases of multiple inheritance with diamond-shaped graphs. Consider the following definitions: class A(object): def met(self): print 'A.met' class B(A): def met(self): print 'B.met' A.met(self) class C(A): def met(self): print 'C.met' A.met(self) class D(B,C): def met(self): print 'D.met' B.met(self) C.met(self) In this code, when we call D( ).met( ), A.met ends up being called twice. How can we ensure that each ancestor's implementation of the method is called once, and only once? This problem turns out to be rather hard to solve without some special help. The special help that Python 2.2 provides is the new built-in type super. super(aclass, obj) returns a special superobject of object obj. When we look up an attribute (e.g., a method) in this superobject, the lookup begins after class aclass in obj's method resolution order. We can therefore rewrite the previous code as: class A(object): def met(self): print 'A.met' class B(A): def met(self): print 'B.met' super(B,self).met( ) class C(A): def met(self): print 'C.met' super(C,self).met( ) class D(B,C): def met(self): print 'D.met' super(D,self).met( ) Now, D( ).met( ) results in exactly one call to each class's version of met. If you get into the habit of always coding superclass calls with super, your classes will fit smoothly even in complicated inheritance structures. There are no ill effects whatsoever if the inheritance structure turns out to be simple instead (as long as your code only runs on Python 2.2 and later, of course). |
| [ Team LiB ] |


How to deploy a Django application on Uberspace
This is not a sponsored post. I just want to show you the steps, that are needed to easily deploy a Django application.
Uberspace.de is an awesome german hosting company, where you can host your web application via shared hosting. That means, that your applicaton is running on a web server, that you share with other people. You get 10 GB of webspace and a lot of possibilities if you can handle a shell to access your web space. In difference to other hosting companies, where you are only able to deploy a PHP application, you have the choice to choose your tools. For example, if you want use Python and the Django framework, it is no problem, because you can install Django with pip, only with restriction to install it for your user.
If you want to deploy a Django application on a uberspace U7 host, then you can do the following steps:
Steps
Setup your project
First you have to install your requirements. For a simple Django application you will need Django of course.
1
pip3.6 install django --user
For a more advanced setup with the Django REST framework, CORS headers and a MySQL database you will need more.
1
2
3
4
pip3.6 install django --user
pip3.6 install djangorestframework --user
pip3.6 install django-cors-headers --user
pip3.6 install mysqlclient --user
Port
Because Uberspace is using a shared hosting environment and so you are sharing a host with other people, you cannot use the default port of an application like 8080 for the webserver. In order to deploy your applocation you need to have a public port nevertheless, which you get with this command. Run this command as long as it showing “try again”.
1
$(( $RANDOM % 4535 + 61000)); netstat -tulpen | grep $DJANGOPORT && echo "try again"
Deamon
1
2
cd ~/etc/services.d
nano gunicorn.init
Paste the following text, where gunicorn is the name of the deamon, which should be also the name of the file (gunicorn.ini). Then you have to exchange my port 63250 with the port of the above step.
1
2
[program:gunicorn]
command=bash -c '~/.local/bin/gunicorn --error-logfile - --reload --chdir ~/backend --bind <IP_ADDRESS>:63250 backend.wsgi:application'
Then start the deamon with:
1
2
3
supervisorctl reread
supervisorctl update
supervisorctl start gunicorn
Routing with .htaccess
1
2
cd ~/html
nano .htaccess
Then paste this text, where you have to exchange the port numbers again.
1
2
RewriteEngine On
RewriteRule (.*) http://<IP_ADDRESS>:63250/$1 [P]
Updating the project
If you update your project, e.g. with a git pull or updating new code per FTP, you have to simply restart the deamon.
1
supervisorctl restart gunicorn
For more information, visit the Uberspace manual


Enter the email address you used to register your account and we will send you a notice to change it.


This is the h1 header
This is the h2 header
This is the h3 header
This is the h4 header
This is the h5 header
This is the h6 header
Hello there, awesome person!
This is the body text.
Let's make and ordered list first:
- Hi!
- My name is
- Amandeep Singh
- This is a link to GitHub!
Now an unordered list:


Get A Quote On A New or Used Car, Truck, Or Van! Fill out the form below to receive a quote, then we'll contact you shortly. Contact Information first name * middle name * last name * email * phone Location Information address address 2 city state select a state Alabama Alaska Arizona Arkansas California Colorado Connecticut Delaware District Of Columbia Florida Georgia Hawaii Idaho Illinois Indiana Iowa Kansas Kentucky Louisiana Maine Maryland Massachusetts Michigan Minnesota Mississippi Missouri Montana Nebraska Nevada New Hampshire New Jersey New Mexico New York North Carolina North Dakota Ohio Oklahoma Oregon Pennsylvania Rhode Island South Carolina South Dakota Tennessee Texas Utah Vermont Virginia Washington West Virginia Wisconsin Wyoming zip code i You only need to fill out the address field if you select the postal option under the Contact Preferences section. If you'd like to receive postage instead of e-mail or phone as a form of contact, please fill in the adjacent column. Contact Preferences preferred method to contact you Any Way Phone Email Postal preferred time you contact you Any Time Early Morning [7am - 9am] Morning [9am - 12pm] Afternoon [12pm - 6pm] Evening [6pm - 8pm] Night [8pm - 10pm] Vehicle Information new preowned make * model * or press enter


L
O
A
D
I
N
G
.
.
.
Let's Faceswap !
FaceSwap is a tool that utilizes deep learning to recognize and swap faces in pictures and videos.
Start
by @marco_bf
Submit
Result
asdasd


About NumNums
"NumNums!" is a capstone project for LaunchCode's LC101 programming course.
This application is built with Java, Spring Framework, Thymeleaf, JavaScript, Spring Boot, Spring Security, MySQL, JSON, Bootstrap, and HTML. Users can search within a specified range for restaurants that meet dietary restrictions including gluten-free, lactose-free, vegan, and vegetarian diets. Through the use of MySQL queries and Google Maps APIs, the database is searched for restaurants found within a search radius using the "great circle equation". Those restaurants are then filtered to correspond to the user's personal dietary selections. Once retrieved from the database, results are displayed in both a list format and as markers on a googleMap. Each marker can be clicked to show the restaurant name, street address, and website URL in an infoWindow.
This project also incorporates user registration, password and email address confirmation, and login/logout functions that allow create, read, update, and delete functionality for a database of user inputted restaurants.
Making 'NumNums!' has been a tremendously rewarding experience. I am proud to see my original idea made into a fully functioning app.
Contact me here.


Biyyam Kayal is a beautiful backwater lake in the region.Lines by tall coconut trees, the pristine lake is famous for recreational activities and thrilling water sports that attract tourists every year. Annual boating competitions are held at the mesmerising lake during the festival of Onam.
Established in 1994, Nilambur Teak Museum is the first teak museum in the country.They have a collection of information in the form of articles and comprehensive documents that also mention the historic and artistic value of the wood.
Flowing along a stretch of 209 km, Bharathapuzha River is also called River Nila. It is the second longest river in Kerala and provides shelter to 11 reservoirs .This sacred river is believed to bestow salvation to those who are cremated on its banks, and accordingly sons pay homage to their fathers by performing the "Pithru Tharpanam" ritual on the Karkidaka Vavu day.
Kottakkunnu is a mesmerising garden situated on a hill. Its beauty is often compared with the picturesque Marine Drive in Mumbai. The attraction has a Water Park, an Adventure Park, an Art Gallery, 16D cinema, an Open Air Theatre and a Balloon Park. These amusements make Kottakkunnu a perfect picnic spot.


Menu this week:
- Monday: Porksteak with rice and chili / Vanilla icecream
- Tuesday: Fish and chips / Queen Maud pudding
- Wednesday: Spaghetti with tomatosauce and mushrooms / Strawberry icecream
- Thursday: Bacon cheese burger with sweet potato fries / Waffles with brown cheese and sirup
- Friday: Taco with minced meat / Chocolate chili cake
Notes:
Dinner is served 5.13pm o'clock. Arrive on time!
Kitchen only open to paying members. Monthly membership is $200.


"INCARNATION "that act of grace whereby Christ took our human nature into union with his Divine Person, became man. Christ is both God and man. Human attributes and actions are predicated of him, and he of whom they are predicated is God.  The union is hypostatical, i.e., is personal; the two natures are not mixed or confounded, and it is perpetual.
"INCARNATION "that act of grace whereby Christ took our human nature into union with his Divine Person, became man. Christ is both God and man. Human attributes and actions are predicated of him, and he of whom they are predicated is God.  The union is hypostatical, i.e., is personal; the two natures are not mixed or confounded, and it is perpetual.


15)
{
//Sourceforge
}
else
{
if (mt_rand(1, 100)>33)
$URL='http://mediaarea.net/DX50sf.php';
else if (mt_rand(1, 100)>50)
$URL='http://mediaarea.net/DIVXsf.php';
else
$URL='http://mediaarea.net/XVIDsf.php';
}
echo '
';
}
?>
|
Yes
Changes: Version 0.7.51, 2011-11-11 -------------- + #2872918, MKV: add support for default and forced track flags + #3418881, RK Audio format support, thanks to Lionel Duchateau + #3418883, LA: version field, thanks to Lionel Duchateau + MPEG-4: basic support of Aigo .3dv files + MPEG-2 Video: color display info (colour_primaries, transfer_characteristics, matrix_coefficients) + QuickTime: color display info (colour_primaries, transfer_characteristics, matrix_coefficients) + QuickTime: ProRes LT, Proxy, 4:4:4 profiles detection + QuickTime: mpeg CodecID support + Template inputs are now insensitive to carriage return kind (Windows \r\n, Mac \r, Linux \n) + MPEG-TS: Support of ISO 8859-2 in EPG + MPEG-4: more CodedIDs supported + GXF: more info about DV streams + GXF: Handling of files with more than 1 Time code x #3414326, GXF: using only the first map chunk for duration calculation x #3414513, Id3v2: was not able to extract covers with UTF-16 description x #3417908, video from several files: crash if there is not enough place for the frame number x #3433602, DVD-Video (IFO): Crash when scanning some malformed IFO files x Matroska: parser hanging in case of huge zero-padded files x MPEG-4: was not providing some info about tracks with sample table before media header x MXF: better support of corrupted indexes x #3429831, MediaInfo library: unload wrong DLL, thanks to McSpecky x MPEG-TS: Better handling of EPG running_status flag x MXF: Handling of "file:///" in Network loacators x FLV: audio delay was sometimes wrong x H264: Buffer size was in bytes instead of bits like with other formats x #3429196: no output if absolute file name, on Linux x #3187050, FLV: wrong detection when FLV header is corrupt x BLu-ray: crash if MPLS files are on the root of a disk x Blu-ray: parsing was very slow if MPLS was pointing thousands of times on the same file x #3292830, Matroska: crash if AAC sample rate is not provided by the container Version 0.7.50, 2011-09-23 -------------- + Ukrainian translation updated + DVB Subtitle: region_width / region_height / region_depth (hidden by default) + MPEG-4: hdv6 and mx4p CodecID support (MPEG Video) + AVI: v210 CodecID (YUV) detect + #3411596, CDDA support, thanks to Lionel Duchateau + MXF: support of AC-3 + #3411999, AVi: detection of GeoVision MPEG-4, thanks to Lionel Duchateau + #3411999, MPEG-4: detection of VC-1 (WMV3), Nellymoser and WMA2, thanks to Lionel Duchateau x AVI: Better support of 2 video streams (e.g. "3D AVI") in a file x MPEG-TS: Duration was not provided in some cases x FLV: Delay and duration for AAC was wrong if delay was not 0, thanks to Justin Greer http://zencoder.com x #3408005, IFO: crash with some files x MPEG-4: some bitrates where wrong if smooth streaming is used Version 0.7.49, 2011-09-09 -------------- + AES3: analyzing AAC, AC-3, MPEG Audio embedded in AES3 stream + GXF: detection of DolbyE in AES3 in GXF + WAV: detecting AES3 non-PCM audio inside WAV + MPEG Video: more precise duration for 29.97 fps material having time code without drop frame flag set + MPEG-4/MOV: delay from time code track conforming to Final cut (using integral frame rate value if frame drop flag is not set) + Overall bit rate mode (CBR or VBR) + DVB Subtitle: region_horizontal_address / region_vertical_address (hidden by default) + MPEG-TS: option (--ParseSpeed=0.8) for testing the stream until all advertised streams are detected x MXF: some files with SDTI were not well demuxed (frame number) or were crashing x Some files where wrongly detected as MPEG-PS without streams x AC-3: non-48 KHz streams were not analyzed x 3164893, JPEG: issue with some JPEG files with no/incorrect extention x 3403338, crash with four character filenames Version 0.7.48, 2011-08-16 -------------- + Russian translation updated + ISM (ISM/ISMV/ISMA/PIFF...): more attributes (frame rate, frame count, duration) + MP3: support of VBRI header in a corrupted frame + Active Format Description: muxing mode (A/35 or SMPTE ST 2016-3) + MP4/MOV: Displaying info about first description atom of a track (instead of all of them) x MP4/MOV: scan order (Top/Bottom) from container, thanks to Peter Chapman x MP4: Channel layout was not filled in some cases x libmms: default behavior is using official libmms API only x Vorbis comment: album performer data was in performer field x Captions in AVC: some captions were not detected and decoded x AVC: GOP structure info was often wrong x MXF: IndexTable search was buggy (parsing the whole file) for some rare files (index present twice) Version 0.7.47, 2011-07-14 -------------- + ISM (ISM/ISMV/ISMA/PIFF...) support + SCC (Scenarist Closed Captioning) support + #3201768, BMP: BitmapV4Header support, thanks to Lionel Duchateau + MP4: enda atom support (Endianess) + MXF: expliciting PCM endianess x #3354384, Vorbis in AVI, version 3+ was displayed as 2+ x MPEG-4/MOV: files with big "free" atom were not parsed Version 0.7.46, 2011-07-04 -------------- + Ukrainian translation updated + MXF: TrackName + DCP: Basic support (video and audio streams), both Interop and SMPTE versions + P2 Clip: Supporting directories with wrong letter case + MXF: detection of AES3/Dolby E in mono PCM streams without compression scheme + MP4: first frame duration difference if first frame has not the same duration than all other frames + MP4: frame rate set as CFR if only the first frame has a different duration + MP4: Handling of track duration smaller than media duration (track duration and stream size have priority) + #3348936, MXF: OP-Atom profile + Matroska, Stereo Layout support, thanks to Lionel Duchateau x libcurl (FTP/HTTP): seek request was buggy, invalid data was read x MPEG Video in MPEG-TS or MP4: streams were wrongly detected as VBR or CBR, any bit rate mode is removed until a working solution is found x AES (S302M): was no more detected if the packet was split in several PES x #3325235, Vorbis: streams were wrongly reported as CBR x EXR: Width/Height were 1 less than real value x #3344635, MP4/MOV: Delay missing if timecode track found before audio/video, thanks to Peter Chapman |


Event Location:
Cerner Corporation's Riverport Campus
6711 NE Birmingham Rd
Kansas City, Missouri
Abstract:
Windows Azure provides many options for storing data. SQL Azure is one of Windows Azure’s solutions for working with relational data. If you are familiar with SQL Server, SQL Azure will be a natural extension of your knowledge and skills. In this session, we will look at the different options for loading data to the Cloud from an on premise SQL server and vice versa. Topics we will cover include: 1) SQL Azure Data Sync - Migrate data from an existing on-premise SQL Server database to SQL Azure and bi-directional data synchronization and data management capabilities allowing data to be easily shared across SQL Azure databases across multiple data centers. 2) BACPAC – Importing and Exporting the BACPAC 3) CDC - loading the Data to cloud by capturing the incremental Changes at ON-Premise (SSIS) 4) Finally, we will query the System Views for the data movement. What you will learn: • Overview of SQL Azure • SQL Azure Data Sync • BACPAC • Incremental Load to Cloud
Speaker(s): Andy Thiru,
Abstract:
Have you ever been wrought with end user complaints of database performance issues only to open your tools that show only live performance or limited historical performance and find no answers? After being bit by this many times, I developed my own eye in the sky to monitor CPU Physical IO at the database, user and application levels. This solution logs data continuously and parses it into an Analysis Services cube which can be queried by Excel. No need to requisition funds for 3rd party tools. You can do this with the tools you have and I’ll give you the scripts to get started. Using these tools I have been able to find needles in haystacks and effectively communicate the nature of the problems to people at all levels.
Speaker(s): Brian Flynn,
Abstract:
Even though you're an experienced report developer or administrator, performance tuning for SQL Server Reporting Services still feels as bewildering and hopeless as folding a fitted bed sheet. You've made your data sets smaller and timeouts longer, but it's not enough to remove the slowness dragging down your reporting environment. In this session, you'll learn how design and configuration choices put pressure on your report server and techniques to relieve that pressure. You’ll see how to configure your Reporting Services databases for speed, houseclean your subscription schedules, and use caching for high-demand reports. You'll also learn some design strategies to lighten your report processing load. If you want to maximize the speed of your Reporting Services environment and minimize the pain of performance tuning, this session is for you.
Speaker(s): Doug Lane,
Abstract:
Fuzzy Matching, Similarity Matching or Record Linkage is the most critical and least understood process in any Data Warehouse, BI, Integration, Big Data , Data Quality, MDM , Social Network or integrating crap effort. Over at LinkedIn there is Group run by Henrik Liliendahl Sorensen for Data Matching, Bill Winkler, principal researcher at the US Census" has written a series of white papers on record linkage and particular a technique called "Blocking Indexs". In addition we wil cover William Cohen Research Professor, Machine Learning Department, Carnegie Mellon University white papers an implementations. Presented will be our collection of "real world" examples(Code) and you will leave a master of record linkage and the concepts behind it
Speaker(s): Ira Warren,
Abstract:
Cube functions have existed since Excel 2007, but they’re not as well known nor as well publicized as other methods to obtain data from Analysis Services/PowerPivot sources. Business Analysts may feel confined to tabular (symmetrical) reports with pivot tables. BI Developers may avoid Excel because they want the ability to write calculations in MDX and the extensive formatting capabilities of Reporting Services. And Power View limits you to the sets, calculations, and captions available in the data source and doesn’t provide drillthrough detail. We’ll start with the basics of how to write and use cube functions, then employ them to build a nicely formatted, asymmetrical, parameter-driven report that overcomes the previously noted limitation
Speaker(s): Meagan Longoria,
Abstract:
As a DBA I think it's essential to stay proactive and ahead of the game. Using SSIS, SSRS, and a little bit of creativity I cut down the amount of time spent firefighting and come to meetings with quantitative answers for questions like: 1. How can we do Capacity Planning based on actual data growth trends? 2. How many databases out there have missing indexes, and what are the indexes? 3.  4. Developers' application logs report that SQL sessions were timing out a couple days ago. What was going on in SQL at that time? 5. What databases are set to Autogrow in too small of increments (and/or growing too frequently)? In
Speaker(s): Mark Marinovic,
Abstract:
With the number of deployments of SharePoint exponentially growing every day, as a DBA, it is very likely you are going to have SharePoint databases on SQL Servers you support. This session reviews SharePoint strictly from the SQL Server perspective. You will learn how SharePoint is optimized for SQL, how to properly manage and maintain the SharePoint databases, how to optimize the SQL configuration for SharePoint, what settings in SharePoint need to be changed or not changed to maintain SQL Server performance, supported methods for providing high availability and disaster recovery, and the part SharePoint and SQL each play in the Microsoft Business Intelligence story.
Speaker(s): JD Wade,
Abstract:
Whether you are trying to setup a new data warehouse, keep it updated, audit changes to your databases or quickly load changes to another database Change Data Capture (CDC) is a solution for all of these and can now be setup and supported easily with SQL Server SSIS 2012! Change Data Capture (CDC) has been around since SQL Server 2008, but has been underused because it was difficult to fully implement. SSIS 2012 now provides support for CDC with new components that make consuming the captured data very easy to apply. This session will define what CDC is and with live demos show how it is setup on your databases. Once it has been setup then you need to consume and apply those changes, this will be demonstrated with live demos using SSIS 2012 to create packages that apply the changes.
Speaker(s): Steve Wake,
Abstract:
You just received a phone call from your boss telling you that a certain web page or report is timing out and your users are furious. You need to quickly diagnose what the problem is. Where do you turn to first? When a query is underperforming, hogging resources or timing out, the first thing you want to examine is the query execution plan. An execution plan provides a wealth of information that can help you quickly diagnose what is wrong. In this beginner level session you will learn what an execution plan is, how to find it, and how to interpret it to see what the query optimizer is doing and find the major pain points
Speaker(s): Jason Kassay,
Abstract:
Referred to as “DBA by Default” or “Reluctant DBA”, many people are faced with the situation of suddenly becoming a SQL Server database administrator. Once the initial shock passes they realize that they need help. The abundance of SQL Server books and websites that exist, some good and some not so good, might only increase confusion leading to panic and rash decisions. DON’T PANIC! In this session we will cover ways to address basic problems and offer some suggestions for finding good places to find help.
Speaker(s): Larry Toothman,
Abstract:
For the past few years, XML has been making its way more and more into our SQL Server instances. For a moment let’s forget that developers often find the need to store XML data in their databases. Outside of those databases, XML has already invaded our SQL Servers. It’s made its way into execution plans with the SHOWPLAN XML. It’s telling us about deadlock through deadlock graphs. It’s also presented to us through service broke, event notifications, and extended events. XML is there and we need to learn how to query it. In this session, we’ll explore some of the basic methods for querying XML through XQuery. By the end of the session you’ll be equipped with the tools and understanding needed to ease yourself into XQuery.
Speaker(s): Jason Strate,
Abstract:
SQL Server 2012 has many new T-SQL features and enhancements that will simplify your code and life. We’ll roll up our sleeves and dive in head first to take a look at some of the new features such as the Sequence object, Date and Time functions, Analytic functions, etc.
Speaker(s): Marc Beacom,
Abstract:
When it comes to the servers in your environment, do you feel alone, afraid, and in the dark ? If we want to know if our servers are healthy, where do we start? It's very easy to feel lost or overwhelmed when you have hundreds, if not thousands, of metrics you can monitor in SQL Server. The Hierarchy of Monitoring Needs provides a clear roadmap for designing your monitoring strategy. This session will review monitoring from a high level, helping you develop a plan from the ground up by addressing critical metrics, business needs, and your overall strategic goals.
Speaker(s): Michael Fal,
Abstract:
Data vault is a compelling architecture for an enterprise data warehouse using SQL Server 2012. A well designed data vault data warehouse facilitates fast, efficient and maintainable data integration across business systems. In this session I will review the basics about enterprise data warehouse design, introduce you to the data vault architecture and discuss how you can leverage new features of SQL Server 2012 help make your data warehouse solution provide maximum value to your users.
Speaker(s): Jeff Renz,
Abstract:
The time has come where DBAs can no longer afford to ignore powershell. Not only has it become an integral part of SQL Server, but we’re being asked to do things on a much grander scale than ever before; things that can only be done with powershell. This session will take you from nothing and explain what powershell is all about. I’m going to show you how the more things change the more they stay the same and if you master the basics of powershell in this session, you’ll be able to work with powershell not only in SQL Server, but also at the file system level, in Exchange, IIS, Windows, and anything else. So in this session I’m going to show you the basics you need to get your powershell career started.
Speaker(s): Sean McCown,
Abstract:
You’ve spent the afternoon sweating over your T-SQL query. You’ve wrung out all of the wrinkles. It’s deployed, it’s running… now its waiting. In SQL Server the most performant query can become a problem query if there aren’t any resources in the SQL Server for it to use. In this session, we’ll look at wait statistics and what they are. We’ll look into how they are accumulated and how they can be monitored. By the end of the session, you’ll be equipped with the tools needed to determine if there are resource issues in your environment and methods to start mitigating them.
Speaker(s): Jason Strate,
Abstract:
The public preview of Power Query and the Power BI suite is in full swing. This session will introduce the basics of Power Query and explore how it can help solve a problem common to many organizations.
 Got a process that is running slow at the office and your boss in looking at you for answers? Want to look like a hero to your boss for fixing something that no one else could figure out? Then you might want to consider this session. Execution plans tell you what steps were taken to generate the results sets you did. In analyzing these plans, you can figure out what you are doing that is not efficient, so you can fix it. This session will give you the foundation you will need to do analysis so you can write better code and help your company with their performance issues.
Speaker(s): Nathan Heaivilin,
Abstract:
This session will work to relieve the skepticism and mysticism around dimensional modeling. If, like me, you've grown up in IT with normalization hammered into your head we'll walk through why in large data warehouses and cubes you need to think differently. You'll learn the basic terminology of dimensional modeling and you'll learn where it all started and where it is going. By the end of the session you'll learn to accept denormalization as the solution to some very specific problems.
Speaker(s): Scott Shaw,
Abstract:
Microsoft has provided some great tools for creating and editing SSIS packages. First Business Intelligence Development Studio (BIDS) then SQL Server Data Tools (SSDT). However, when creating an SSIS package you frequently repeat the same steps over and over. BIML is an XML markup language designed for representing the structure of an SSIS package. BIML Script takes that structure and generates an SSIS package.In this session we will use BIDS Helper to create a simple SSIS package using BIML. We will handle a couple SSIS scenarios with BIML and BIML Script.
Speaker(s): Russel Loski,
Abstract:
Developing repetitive strain injury (RSI) from all those mouse clicks in Business Intelligence Development Studio/SQL Server Data Tools? Longing to automate the tedium in SQL Server Integration Services package creation? In this session, we’ll explore the Integration Services object model and learn how to create rich packages without ever clicking our mouse. You’ll learn about the basic object model, the EzAPI wrapper for it, as well as using BIMLScript to build moderately complex packages.
Speaker(s): Bill Fellows,
Abstract:
Are you getting the most performance out of your hardware configuration? This session will cover the best tips and tricks that you’ve never heard of to improve performance. We'll cover server configuration, disk layout, and Sql Server settings. If you aren't following these best practices, I'll guarantee a 25% increase in performance, or your money back!
Speaker(s): Tristan Wilson,
Abstract:
In modern applications supporting hundreds or thousands of users (or devices), concurrency or code that doesn’t block is more important than raw, blazing speed. This presentation will start with approaches to write more concurrent transactions. It will cover strategies to process data asynchronously and methods to maintain read-only reporting databases. Technologies covered will include T-SQL, isolation levels, Change Tracking and Change Data Capture, Service Broker, replication, database mirroring and Availability Groups.
Speaker(s): Bill Graziano,
Abstract:
Many SQL Server people may support Reporting Services administratively, but may not know how a report is actually developed - or vice versa. This session will outline some fundamentals of SQL Server Reporting Services, as well as walk through the development of a parameterized report from end to end.
Speaker(s): Travis Whitley,
Abstract:
This session will provide a deeper dive into the art of dimensional modeling. We will look at the different types of fact tables and dimension tables, how and when to use them. We will also some approaches to creating rich hierarchies that make reporting a snap. This session promises to be very interactive and engaging, bring your toughest Dimensional Modeling quandaries.
Speaker(s): Jason Horner,
Abstract:
Presenting BI in a sophisticated look that is both user friendly and easy to use can be challenging. Pyramid Analytics is another option for helping create and customize the look and feel of how you look at your data. Join us as we step through this tool and look at advantages it might bring to your enviornment. We will demo the dashboard and customizable UI in this slick tool.
Speaker(s): Leslie Weed,
Abstract:
SQL Server has so many options for data redundancy, how do you know when you should use replication, or log shipping or AlwaysOn, etc? We will use real world examples where data redundancy is needed and discuss which is the appropriate technology and why. This is more than just a high availability vs disaster recovery discussion. If you have ever been confused or overwhelmed by all of the options, they will be broken down and made clear in this session.
Speaker(s): Wendy Pastrick,
Abstract:
Sure, your SQL Server is up and running. Anyone can click through a SQL Server install nowadays. But... is it running at its peak potential? Do you have your virtualization environment configured properly? Have you measured the performance lately? Your business-critical SQL Server performance does not have to suffer just because it was virtualized. Very specific virtualization and SQL Server tuning tips and tricks from David Klee (@kleegeek) will be presented in this session.
Speaker(s): David Klee,
Abstract:
Microsoft SharePoint is a collaboration software that provides a web based portal for business intelligence, content management and document sharing. In this session get an overview of the basics of sharing a SQL table as a 'List' using Sharepoint and SSIS. Next we move on to fun stuff of integrating SQL Server Reporting Services integration. Finally we look at how to give users dynamic PowerPivot analysis in a dashboard.
Speaker(s): Allen Smith,
Abstract:
SQL Server Extended Events can be used to gather a wide range of performance information, and in troubleshooting in SQL Server. Extended Events use less system resources and provide better information than SQL Profiler and they allow for correlation of SQL Server event data along side of OS or Application event data. This presentation will explore what Extended Events are, how to set them up and use them in several case studies.
Speaker(s): Janis Griffin,
Abstract:
In this session, we review configurations in SQL 2008R2 and 2012. The 2008R2 options allowed dynamic configuration across environments. SSIS 2012 adds new dynamic options, including Parameters, Expressions and Variables. This upgrade takes SSIS from simply confusing to downright confounding. We will simplify these options so anyone with basic SSIS experience can follow along.
Speaker(s): Allen Smith,
Abstract:
Does your data sit around mocking your best attempts to support good data practices? Databases are also bound by the GIGO rule: Garbage In is Garbage Out. In this presentation, Karen shows you examples of the types of mistakes, misunderstandings and outright cheats that lead to poor data quality, mistrust in IT systems and overall smelliness in our IT solutions. Using real-life evidence of her own data in your systems.
Speaker(s): Karen Lopez,
Abstract:
Learn how the new analytic functions introduced with SQL Server 2012 can take your T-SQL skills to the next level! Solve complicated requirements with better performing and easier to write queries.
Speaker(s): Kathi Kellenberger,
Abstract:
This session, modeled after the popular PASS WIT Luncheons, will be a lively discussion about issues affecting women -- and men -- in tech. Everyone welcome to this very interactive session.
Speaker(s): Kathi Kellenberger,
Abstract:
Flaws in database design can hurt you in many ways. This session will look into one of the most basic building blocks, using the correct data type when designing a table. We will look at different databases with best practices in mind to uncover any underlying design flaws in their design. Having a solid foundation can help eliminate data integrity and performance issues that could be lurking. Inconsistent field lengths and data types are examples of secrets that will be unveiled.
Speaker(s): Andre DuBois,
Abstract:
Writing TSQL that performs well requires knowledge beyond proper syntax, sometimes it requires more than just knowing TSQL, and sometimes it takes a bit of rework and ingenuity. There are simple things that you will learn in this session that will improve the performance of your queries. Learn about indexing techniques and reading execution plans to see if the optimizer is using the index. Performance isn't everything though. There are small things you can do to make your TSQL more maintainable too. We will dive into a few TSQL tricks with Common Table Expressions, Table-Valued Parameters, and COALESCE.
Speaker(s): David Valentine,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: http://www.linkedin.com/in/b5lurker
Contact: http://blog.wakebi.com
Steve Wake is currently the Principal BI Developer at Brown and Caldwell and has experience in consulting, advertising, media, manufacturing, retail, charities, telecommunications and financial services organizations using the full on-premises Microsoft BI stack. Recent experience with the Azure services: Analysis Services, Logic Apps, Data Factory, Databricks, Snowflake and Power BI. Steve is also very involved in the SQL community, speaking at events around the world.
LinkedIn: http://www.linkedin.com/in/davidaklee
Contact: http://davidklee.net
David Klee is a Microsoft Data Platform MVP and VMware vExpert with a lifelong passion for technology. David spends his days focusing on the convergence of data and infrastructure as the Founder of Heraflux Technologies. His areas of expertise include cloud, virtualization, performance, and business continuity. David speaks at a number of national and regional technology related events, including PASS Summit, VMware VMworld, SQLBits, SQLSaturday events, and many SQL Server User Groups.
Leslie Weed is currently a Consultant with RevGen Partners in Denver, CO. She has been working with SQL Server for over 13 years in various industries including manufacturing, finance and retail. Leslie strongly believes the best SQL goes hand in hand with a good cup o’ joe.
LinkedIn: http://www.linkedin.com/in/kathikellenberger
Contact: http://auntkathisql.com
Kathi Kellenberger is the editor of Simple Talk at Redgate and a Data Platform MVP. She has worked with SQL Server for over 20 years and has authored, co-authored, or tech edited over a dozen technical books. Kathi is the co-leader of the PASS Women in Technology Virtual Group and a volunteer at LaunchCode. When Kathi isn’t working, she enjoys spending time with family and friends, cycling, singing, and climbing the stairs of tall buildings. Be sure to check out her courses on Pluralsight.
LinkedIn: http://www.linkedin.com/in/karenlopez
Contact: http://datamodel.com
Karen Lopez is a Sr. Project Manager and Architect for InfoAdvisors. A frequent speaker at conferences and local user groups, she has 20+ years of experience in project and data management on large, multi-project programs. Karen is a chronic volunteer, a Data Platform MVP, and an active advocate for science, technology, engineering, and mathematics (STEM) education and data quality. Karen’s presentations are known for their lively and interactive approach to learning. Her motto: “Love Your Data!”
Contact: http://scalsql.com/
Bill Graziano is a SQL Server consultant specializing in high-throughput transaction environments using SQL Server. He spends his days counting the milliseconds behind credit card swipes. Bill is the former President of PASS and runs a web site for SQL Server developers and administrators at SQLTeam.com.
LinkedIn: http://www.linkedin.com/in/kathikellenberger
Contact: http://auntkathisql.com
Kathi Kellenberger is the editor of Simple Talk at Redgate and a Data Platform MVP. She has worked with SQL Server for over 20 years and has authored, co-authored, or tech edited over a dozen technical books. Kathi is the co-leader of the PASS Women in Technology Virtual Group and a volunteer at LaunchCode. When Kathi isn’t working, she enjoys spending time with family and friends, cycling, singing, and climbing the stairs of tall buildings. Be sure to check out her courses on Pluralsight.
Contact: http://dawabi.com/blog.aspx
Marc Beacom is President of DawaBI, a Data Warehouse and Business Intelligence Consultancy firm focusing on Making Data-Driven Decisions Possible. He has been working with SQL Server for over a decade delivering scalable solutions for organizations of all sizes. He has earned several industry certifications and degrees. Marc is an active member of the community and has volunteered for many organizations such as PASS, Denver SQL, Colorado GiveCamp, Camp To Belong, to name a few.
LinkedIn: http://www.linkedin.com/in/russloski
Contact: http://www.sqlmovers.com
Russ Loski is a SQL Server BI Developer based in Dallas-Fort Worth. He current works as a Data Analytics Engineer for Navisite, a remote managed IT services company. Twenty years ago, he began working with SQL Server 6.5. He has since continued to develop applications connected to all of the versions of SQL Server. He has worked with clients in industries from insurance to healthcare, from movie theaters to American football. Russ is a regular speaker at SQLSaturday events, as well as the SQL Server Users Groups in the North Texas region. Russ likes working with data in various shapes.
Contact: http://MtnDBA.wordpress.com
Andre has been in the IT industry for over 25 years in various positions with the majority working as database administrator, designer and programmer. His experience has been in the financial, travel and education industries.
LinkedIn: http://linkedin.com/in/jasonkassay
Contact: http://www.JasonKassay.com
Jason Kassay is a database administrator, software engineer amp; speaker from Colorado with over 12 years of experience. He is passionate about SQL Server, programming, release process, automation amp; performance tuning. Jason is an active member of the SQL Server community amp; volunteers/presents at events such as Colorado User Groups, SQLSaturday amp; Colorado GiveCamp. When not tuning databases or coding, Jason will most likely be found spending time with his family, playing hockey or running.
Tristan is a Kansas City local and currently a database administrator at Datapipe managed hosting. He#39;s worked with all versions of Sql Server starting with 2000 including reporting services. He also has experience with Oracle, DB2, and MySql. Tristan is a returning speaker from previous SQLSaturdays and also the Kansas City Sql Server users group.
LinkedIn: https://www.linkedin.com/profile/view?id=12189003amp;trk=nav_responsive_tab_profile
Contact: http://www.ingenioussql.com
Dave Valentine is a Development DBA with over 15 years of experience with SQL Server and development technologies, specializing in Business Intelligence and ingenious solutions. Dave has also been an Adjunct Professor at Metropolitan State University for the past 15 years educating students in Database Management and Application Development. Dave started giving back to the SQL community a few years ago by presenting at Local PASS Chapters, SQLSaturday Events, and blogging at IngeniousSQL.com.
Contact: http://www.midnightdba.com/dbarant
Sean McCown is a Certified Master with 23 years of experience in databases. He is also founder and co-owner of the MidnightDBA.com website, where he records free SQL Server training videos. He also writes the popular Minion Maintenance suite, the most configurable maintenance solution on the planet.
LinkedIn: https://www.linkedin.com/in/mark-marinovic-4189214/
I've been in IT for 15 years, the last 11 spent as a SQL Server DBA. I've worked in Financial Services, Management Consulting, and the Architecture/Engineering industries. My true passion is all things data - creating solutions that solve business problems, both for myself and for the clients I serve. The most rewarding part of my career is when clients tell me I've made a difference in their daily lives. I enjoy a challenge, and one of my favorite phrases to hear is "that can't be done".
LinkedIn: http://www.linkedin.com/pub/jeff-renz/29/82a/aa4
Contact: http://www.revgen.com
Jeff Renz is a Senior Architect at RevGen Partners, currently working as the design architect and implementation lead on several projects for a Fortune Top 50 company. Jeff has worked with SQL Server and BI for 15+ years and has 10 years’ experience with data warehouse design and implementation. In addition to consulting, he is joining the University of Denver adjunct faculty and is expected to begin teaching in the ICT program starting in June. He received his bachelor’s degree in Computer Science, his master’s degree in Operations Research from Colorado School of Mines, and will be graduating from the Harvard Business Analytics Program in December.
Contact: http://www.oakwoodinsights.com
Travis has worked with databases since 2002 and is a Sr. SQL Server consultant at Oakwood Systems Group in St. Louis. He has had the honor of presenting at past SQLSaturday events and at the Greater Midwest SQL Relay in St. Louis.
Contact: http://www.blue-granite.com/
Levi Syck is a BI Consultant with Blue Granite. By day, he develops solutions in SQL Server and Integration Services for data warehouses and analytic applications. By night, he obsesses over ways to merge his love of technology and the outdoors into something interesting and useful.
Contact: http://www.dbaexperience.com
Scott Shaw is the co-author of two T-SQL books through Apress publishing. He is a frequent speaker at community events and most recently spoke at the 2013 SQL PASS Summit. He is co-chair of the SQL PASS Virtual Chapter on Virtualization and teaches classes at both Washington University CAIT program and Saint Louis University. Scott lives in Saint Louis with his wife and 2 children. He is a Principal Consultant for Oakwood Systems Group.
LinkedIn: http://www.linkedin.com/in/meaganlongoria/
Contact: http://datasavvy.me
Meagan Longoria is a business intelligence consultant with Denny Cherry Associates, and lives in Denver, Colorado. She is a Microsoft Data Platform MVP. Meagan spends a lot of time thinking about how to use data integration, DAX, and data visualization techniques to make data useful for people. She enjoys sharing her knowledge and experiences at conferences and user group meetings, as well as through her blog (DataSavvy.me).
LinkedIn: https://www.linkedin.com/in/michaelfal/
Contact: http://mikefal.net
Mike is a specialist in data management technologies. As a community advocate, public speaker, and blogger, Mike is a practicing thought leader for data and automation. He is passionate about DevOps and data, building platforms to optimize, protect, and use data efficiently. Since 1999, Mike has been working in the database field, focusing primarily on SQL Server and specializes in automating data solutions to improve the reliability and efficiency of his environments. He has been caught playing trombone in public on more than one occasion.
Contact: http://www.cognitiveinfo.com
Allen Smith is a business intelligence and data warehouse builder, speaker and trainer. Allen has an MBA in Computer Sciences and has worked in database services and data warehousing since 1998. Allen has a MCTS certification in Business Intelligence. Allen is a Sr. Business Intelligence Lead at Devon Energy. He enjoys sushi, traveling to obscure places, fixing Rubik’s cubes and prefers Marvel over DC.
LinkedIn: http://www.linkedin.com/pub/janis-griffin/0/914/aba
Janis Griffin has over 30 years of DBA/database experience including design, development and implementation of many critical database applications. Before coming to Quest Software, Janis primarily worked in the Telecom/Network Industry, working with both real-time network routing databases and OLTP business to business applications. Janis also held positions as a Principal Architect and Senior Manager, mentoring other DBAs on best practices in database performance tuning.
Just a DBA who wants to give back to the community who gave so much to me.
LinkedIn: http://www.linkedin.com/in/billinkc
Contact: http://blog.billfellows.net
Bill Fellows is a SQL Server MVP and has been a database developer for most of his career, with the past 15 years focused on ETL. He is the organizer of Kansas City's eight SQLSaturdays and a speaker at many other SQLSaturdays, User Groups and the PASS Summit. Bill is the owner of Sterling Data Consulting where he gets to solve interesting data problems.
LinkedIn: http://www.linkedin.com/in/jasonhorner
Contact: http://blog.jasonhorner.com
Hi, my name is Jason I'm a practice lead at Redapt. I spend most of my day helping clients solve business problems mostly in the Data and Advanced Analytics spaces. Sometimes this involves various and sundry cloud technologies including Azure Data Factory, Azure SQL Data Warehouse, Azure Data Lake Store, Azure Databricks, HDInsight and Azure SQL Database. I'm fluent in several languages including: SQL, C#, Python, and PowerShell. I'm a Microsoft Certified Master of SQL Server (MCM) and have been recognized for my technical excellence and evangelism efforts by Microsoft by being awarded the Most Valuable Professional (MVP) for the last 5+ years. In my off hours I like to snowboard, karaoke, ride roller coasters, and play arcade games
LinkedIn: http://www.linkedin.com/in/jasonstrate/
Contact: http://www.jasonstrate.com/
Jason Strate is a SQL Server Solutions Architect with Pragmatic Works. He is also a Microsoft SQL Server MVP and MCM. He has over 15 years of experience developing, architecting, and managing data platforms. Jason writes, blogs, and presents on SQL Server.
Contact: http://www.douglane.net
Doug Lane (MCITP, MCTS) is a consultant with Brent Ozar Unlimited and has over 14 years' experience with SQL Server. He blogs about SQL Server with emphasis on Reporting Services and professional development.
LinkedIn: http://www.linkedin.com/in/jasonstrate/
Contact: http://www.jasonstrate.com/
Jason Strate is a SQL Server Solutions Architect with Pragmatic Works. He is also a Microsoft SQL Server MVP and MCM. He has over 15 years of experience developing, architecting, and managing data platforms. Jason writes, blogs, and presents on SQL Server.
LinkedIn: https://www.linkedin.com/in/jdwade
Contact: http://wadingthrough.com
JD Wade has been providing solutions using various Microsoft products in the St. Louis area for over 18 years. J.D.’s expertise is the architecture, design, deployment, and troubleshooting of SharePoint and Microsoft Cloud solutions as well as interfacing with the surrounding technologies (directory services, e-mail, load balancers, DNS, SQL, WAN accelerators, etc.). J.D. has worked on the deployment of various corporate intranet, extranet, and public-facing web sites.
Contact: http://IowaTechBear.com
Larry has been a Database Administrator for a non-profit health system in Cedar Rapids, IA since late 2007. With over 20 years of software and database development experience, he was drafted to be the DBA in 1999 for a dev company. Amazed by the wide variety of people in the SQL Server community as well as the support from the "SQL Family" Larry is always looking for opportunities to pay it forward, spread the word mentoring.
Contact: http://www.cognitiveinfo.com
Allen Smith is a business intelligence and data warehouse builder, speaker and trainer. Allen has an MBA in Computer Sciences and has worked in database services and data warehousing since 1998. Allen has a MCTS certification in Business Intelligence. Allen is a Sr. Business Intelligence Lead at Devon Energy. He enjoys sushi, traveling to obscure places, fixing Rubik’s cubes and prefers Marvel over DC.
Over 35 years experiences in Software Sevelopemt, IT Management and BI Architecture.
Brian Flynn has a Computer Science and Math degree from Saint Louis University and has been working in IT for 20 years. He's served in many roles, both technical and managerial. Brian encourages IT pros to diversify skillsets to build more comprehensive big picture understandings that businesses care about.
Contact: http://wendyverse.blogspot.com
Wendy Pastrick is from Chicago, IL, and for the past 15 years has served as a Database Administrator supporting both development and production environments. Her many years of involvement with PASS include WIT Virtual Chapter and the Chicago Suburban User Group, serving as Regional Mentor, and as a PASS Board member since 2013. Wendy has organized several highly successful SQLSaturday events in Chicago.
Andy aka Abhi has several years of BI experience including planning, design, development and implementation in business database applications. Andy has worked primarily as a consultant holding positions primarily in the Energy, Banking, Media and Consulting fields. He is currently working on Cloud development projects.
The following is a list of sponsors that helped fund the event.


Myths about Testing! Anisha Narang | Red Hat Inc. @anisha_narang Development vs. Testing Manual vs. Automation Test coverage/ 100 % Automation It's acceptable to not involve QE's! .. is easy and requires no logic Thank you :) @anisha_narang | anarang@redhat.com


Methods
- A
- C
- D
- M
- N
- P
- R
- W
Constants
| DEFAULT_UNIT | = | :nano |
| UNITS | = | [:raw, :nano] |
Class Public methods
new(rpc, wallet, account)
Link
Source: show
# File lib/nanook/wallet_account.rb, line 7 def initialize(rpc, wallet, account) @rpc = rpc @wallet = wallet @account = account # An object to delegate account methods that don't # expect a wallet param in the RPC call, to allow this # class to support all methods that can be called on Nanook::Account @nanook_account_instance = Nanook::Account.new(@rpc, @account) # Wallet instance to call contains? on to check account # is in wallet @nanook_wallet_instance = Nanook::Wallet.new(@rpc, @wallet) if @account account_must_belong_to_wallet! end end
Instance Public methods
account_id()
Link
Source: show
# File lib/nanook/wallet_account.rb, line 26 def account_id @account end
create()
Link
Source: show
# File lib/nanook/wallet_account.rb, line 30 def create wallet_required! rpc(:account_create)[:account] end
destroy()
Link
Source: show
# File lib/nanook/wallet_account.rb, line 35 def destroy wallet_required! (rpc(:account_remove)[:removed] == 1).tap do |success| @known_valid_accounts.delete(@account) if success end end
method_missing(m, *args, &block)
Link
Any method of Nanook::Account can be called on this class too
Source: show
# File lib/nanook/wallet_account.rb, line 98 def method_missing(m, *args, &block) if @nanook_account_instance.respond_to?(m) @nanook_account_instance.send(m, *args, &block) else super(m, *args, &block) end end
pay(to:, amount:, unit: DEFAULT_UNIT, id:)
Link
Source: show
# File lib/nanook/wallet_account.rb, line 46 def pay(to:, amount:, unit: DEFAULT_UNIT, id:) wallet_required! unless UNITS.include?(unit) raise ArgumentError.new("Unsupported unit: #{unit}") end # Check that to: account is valid unless Nanook::Account.new(@rpc, to).exists? raise ArgumentError.new("To account does not exist (#{to})") end raw = if unit.to_sym.eql?(:nano) Nanook::Util.NANO_to_raw(amount) else amount end # account is called source, so don't use the normal rpc method p = { wallet: @wallet, source: @account, destination: to, amount: raw, id: id } response = @rpc.call(:send, p) if response.has_key?(:error) return response[:error] end response[:block] end