JavaScript Xmpp Chat namespace
- Source:
Namespaces
Members
-
<static> bid
-
My bar id
- Source:
-
<static> CONST
-
Some constants
- Source:
-
<static> keepalive
-
Interval for keep-alive
- Source:
-
<static> log
-
debug log
- Source:
-
<static> ls
-
last values which we wrote into localstorage (IE workaround)
- Source:
-
<static> master
-
True if i'm the master
- Source:
-
<static> notice
-
This namespace handle the notice system.
- Source:
-
<static> restore
-
True if last activity was 10 min ago
- Source:
-
<static> restoreCompleted
-
True if restore is complete
- Source:
-
<static> role_allocation
-
True if the role allocation is finished
- Source:
-
<static> storageNotConform
-
storage event is even fired if I write something into storage (IE workaround) 0: conform, 1: not conform, 2: not shure
- Source:
-
<static> to
-
Timeout for keepalive
- Source:
-
<static> toBusy
-
Timeout after normal keepalive starts
- Source:
-
<static> toNotification
-
Timeout for notification
- Source:
-
<static> toNotificationDelay
-
Timeout delay for notification
- Source:
-
<static> toSNC
-
Timeout for storageNotConform test
- Source:
-
<static> triggeredFromBox
-
True if login through box
- Source:
-
<static> triggeredFromElement
-
True if logout through element click
- Source:
-
<static> triggeredFromLogout
-
True if logout through logout click
- Source:
-
<static> triggeredFromPresence
-
True if logout through presence box
- Source:
-
<static> version
-
Version of jsxc
- Source:
Methods
-
<static> _onMaster()
-
Second half of the onMaster routine
- Source:
-
<static> checkMaster()
-
Checks if there is a master
- Source:
-
<static> debug(msg, data, Could)
-
Write debug message to console and to log.
Parameters:
Name Type Description msg
String Debug message data
Object Could
String be warn|error|null - Source:
-
<static> el_exists(selector) → {Boolean}
-
Checks if there is a element with the given selector
Parameters:
Name Type Description selector
String jQuery selector - Source:
Returns:
- Type
- Boolean
-
<static> error(msg, data)
-
Write error message.
Parameters:
Name Type Description msg
String Error message data
Object - Source:
-
<static> escapeHTML()
-
Escapes some characters to HTML character
- Source:
-
<static> exec(fnName, fnParams)
-
Executes the given function in jsxc namespace.
Parameters:
Name Type Description fnName
string Function name fnParams
array Function parameters - Source:
Returns:
Function return value -
<static> getFormattedTime(unixtime)
-
Parse a unix timestamp and return a formatted time string
Parameters:
Name Type Description unixtime
Object - Source:
Returns:
time of day and/or date -
<static> init(options)
-
Starts the action
Parameters:
Name Type Description options
object - Source:
-
<static> isHidden() → {boolean}
-
Checks if tab is hidden.
- Source:
Returns:
True if tab is hidden- Type
- boolean
-
<static> jidToBid(jid)
-
Create comparable bar jid.
Parameters:
Name Type Description jid
- Source:
Returns:
comparable bar jid -
<static> jidToCid(jid) → {String}
-
Creates a CSS compatible string from a JID
Parameters:
Name Type Description jid
type Valid Jabber ID - Source:
Returns:
css Compatible string- Type
- String
-
<static> keepAlive()
-
Sends the keep-alive signal to signal that the master is still there.
- Source:
-
<static> keepBusyAlive()
-
Send one keep-alive signal with higher timeout, and than resume with normal signal
- Source:
-
<static> onMaster()
-
Called if the script is the master
- Source:
-
<static> onSlave()
-
Called if the script is a slave
- Source:
-
<static> prepareLogin()
-
Load settings and prepare jid.
- Source:
Returns:
Loaded settings -
<static> random(max) → {Integer}
-
Generates a random integer number between 0 and max
Parameters:
Name Type Description max
Integer - Source:
Returns:
random integer between 0 and max- Type
- Integer
-
<static> removeHTML(text)
-
Removes all html tags.
Parameters:
Name Type Description text
- Source:
Returns:
stripped text -
<static> restoreRoster()
-
Restore roster
- Source:
-
<static> restoreWindows()
-
Restore all windows
- Source:
-
<static> startKeepAlive()
-
Start sending keep-alive signal
- Source:
-
<static> submitLoginForm()
-
This method submits the specified login form.
- Source:
-
<static> switchEvents() → {string}
-
Executes only one of the given events
Parameters:
Name Type Description obj.key
string event name obj.value
function function to execute - Source:
Returns:
namespace of all events- Type
- string
-
<static> translate(text) → {String}
-
Replace %%tokens%% with correct translation.
Parameters:
Name Type Description text
String Given text - Source:
Returns:
Translated string- Type
- String
-
<static> warn(msg, data)
-
Write warn message.
Parameters:
Name Type Description msg
String Warn message data
Object - Source:


person
Log In
User name
Password
Submit
send
person_add
New User
User name
Password
Retype password
Submit
send


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Class Summary | |
|---|---|
| AbstractAtomicType | |
| AbstractBuiltinType | An abstract type, to be extended by the builtin types. |
| AbstractListType | |
| AbstractSimpleType | |
| XSAnySimpleType | The type xs:anySimpleType. |
| XSAnyType | The "anyType" is a type with arbitrary content. |
| XSAnyURI | The type xs:anyURI. |
| XSBase64Binary | The type xs:base64Binary. |
| XSBoolean | The type xs:boolean. |
| XSByte | The xs:byte type |
| XSDate | The type xs:gYearMonth. |
| XSDateTime | The type xs:dateTime. |
| XSDecimal | The type xs:decimal. |
| XSDouble | The type xs:double. |
| XSDuration | The type xs:dateTime. |
| XSEntities | |
| XSEntity | The xs:NCName type |
| XSFloat | The type xs:float. |
| XSGDay | The type xs:gDay. |
| XSGMonth | The type xs:gMonth. |
| XSGMonthDay | The type xs:gMonthDay. |
| XSGYear | The type xs:gYear. |
| XSGYearMonth | The type xs:gYearMonth. |
| XSHexBinary | The type xs:hexBinary. |
| XSID | The xs:ID type |
| XSIDREF | The xs:IDREF type |
| XSIDREFs | |
| XSInt | The xs:int type |
| XSInteger | The xs:integer type |
| XSLanguage | The xs:language type |
| XSLong | The xs:long type |
| XSName | |
| XSNCName | The xs:NCName type |
| XSNegativeInteger | The xs:integer type |
| XSNMToken | The xs:NMTOKEN type |
| XSNMTokens | |
| XSNonNegativeInteger | The xs:nonNegativeInteger type |
| XSNonPositiveInteger | The xs:nonPositiveInteger type |
| XSNormalizedString | The xs:normalizedString type. |
| XSNotation | The type xs:NOTATION. |
| XSPositiveInteger | The xs:positiveInteger type |
| XSQName | The type xs:QName. |
| XSShort | The xs:short type |
| XSString | The type xs:string. |
| XSTime | The type xs:time. |
| XSToken | The xs:token type. |
| XSUnsignedByte | The xs:unsignedByte type |
| XSUnsignedInt | The xs:unsignedInt type |
| XSUnsignedLong | The xs:unsignedLong type |
| XSUnsignedShort | The xs:unsignedShort type |
XML schema data type models.
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Home
Please Sign Up
First Name
Last Name
Shipping address
Unit Number
Street Number
Street Name
City
Province
Ontario
Alberta
British Columbia
Manitoba
New Brunswick
Newfoundland and Labrador
Nova Scotia
Prince Edward Island
Quebec
Saskatchewan
Postal Code
Contact Number
Phone
Email
Username
Password
Confirm Password
Submit
Reset


|
|
| Flow (Flow other) |
| |
|
Flow | Reset () |
| |
|
Flow | ClearNextIncomingId () |
| |
|
Flow | ClearNextOutgoingId () |
| |
|
Flow | ClearIncomingWindow () |
| |
|
Flow | ClearOutgoingWindow () |
| |
|
Flow | ClearHandle () |
| |
|
Flow | ClearDeliveryCount () |
| |
|
Flow | ClearLinkCredit () |
| |
|
Flow | ClearAvailable () |
| |
|
Flow | ClearDrain () |
| |
|
Flow | ClearEcho () |
| |
|
Flow | ClearProperties () |
| |
|
bool | IsEmpty () |
| |
|
int | GetElementCount () |
| |
|
bool | HasNextIncomingId () |
| |
|
bool | HasIncomingWindow () |
| |
|
bool | HasNextOutgoingId () |
| |
|
bool | HasOutgoingWindow () |
| |
|
bool | HasHandle () |
| |
|
bool | HasDeliveryCount () |
| |
|
bool | HasLinkCredit () |
| |
|
bool | HasAvailable () |
| |
|
bool | HasDrain () |
| |
|
bool | HasEcho () |
| |
|
bool | HasProperties () |
| |
|
object | Clone () |
| |
|
Flow | Copy () |
| |
| void | Invoke< T > (IPerformativeHandler< T > handler, IProtonBuffer payload, ushort channel, T context) |
| | Visit the performative using a handler instance and provided context data. More...
|
| |
|
override string | ToString () |
| |
|
|
static readonly ulong | DescriptorCode = 0x0000000000000013UL |
| |
|
static readonly Symbol | DescriptorSymbol = Symbol.Lookup("amqp:flow:list") |
| |
|
|
uint | NextOutgoingId [get, set] |
| |
|
uint | NextIncomingId [get, set] |
| |
|
uint | IncomingWindow [get, set] |
| |
|
uint | OutgoingWindow [get, set] |
| |
|
uint | Handle [get, set] |
| |
|
uint | DeliveryCount [get, set] |
| |
|
uint | LinkCredit [get, set] |
| |
|
uint | Available [get, set] |
| |
|
bool | Drain [get, set] |
| |
|
bool | Echo [get, set] |
| |
|
IDictionary< Symbol, object > | Properties [get, set] |
| |
| PerformativeType | Type [get] |
| | Provides the type of this performative. More...
|
| |
◆ Invoke< T >()
Visit the performative using a handler instance and provided context data.
- Template Parameters
-
| T | The type of context that is provided |
- Parameters
-
| handler | The handler instance to visit |
| payload | The payload that the performative was sent with |
| channel | The channel the performative was sent on |
| context | The context for this visitation |
Implements Apache.Qpid.Proton.Types.Transport.IPerformative.
The documentation for this class was generated from the following file:
- src/Proton/Types/Transport/Flow.cs


Universal-ctags Hacking Guide¶
- Version
Draft
- Authors
universal-ctags developers
- Web Page
Universal-ctags was created to continue the development of Darren Hiebert’s Exuberant-ctags after activity on that project unfortunately stalled.
Reza Jelveh<EMAIL_ADDRESS>initially created a personal fork on GitHub and as interest and participation grew it was decided to move development to a dedicated GitHub organization.
The goal of this project is to maintain a common/unified space where people interested in improving ctags can work together.
This guide is primarily intended for developers. Users should first consult the ctags.1 man page.
This is a draft document. Proofreading and pull-requests are welcome!
- Introduced changes
- Importing changes from Exuberant-ctags
- Parser related changes
- New and extended options
- Changes to the tags file format
- Reference tags
- Automatic parser selection
- Pseudo-tags
- Parser specific fields
- Parser specific extras
- Parser specific parameter
- Customizing xref output
- Incompatible changes in command line
- Skipping utf-8 BOM
- Readtags
- Request for extending a parser (or Reporting a bug of parser)
- Contributions
- Parsers
- Output formats
--_interactive
Mode- Choosing a proper parser in ctags
- Running multiple parsers on an input file
- Building ctags
- Testing ctags
- Extending ctags
- Tips for hacking
- Relationship between other projects
- The development guideline
- Man pages
- Who we are


Try to right click on this div:
This one does not have a context menu attached, try also a right click:


 With multimethods, you can define a function which is polymorphic with respect to a given hierarchy and arbitrary dispatch value. The hierarchy is actually a directed acyclic graph, but you can adjust method priority to address the diamond problem.
Unfortunately, Clojure’s dispatch mechanism is baked into the defmulti and defmethod forms. If you want multimethod-style dispatch, you need a Var to hold your multimethod. Similar to the circumstances which prompted the creation of backtick, I discovered that there was an opportunity to decomplect a part of the core library to extract a useful subcomponent. In this case, the datastructure which describes dispatch rules was complected with the identity which points to those dispatch rules. As a result, it’s impossible to treat a multimethod as an immutible value.
So I created dispatch-map. A dispatch map is just like a regular Clojure map, but it comes coupled with a dispatch function and hierarchy. Looking up keys in a dispatch map has the same dispatch behavior and caching functionality of multimethods. However, unlike a multimethod, a dispatch-map is a true value. The standard map operators assoc, dissoc, etc, return a new dispatch-map, leaving the original unmodified. This enables you to manipulate dispatch maps like any other Clojure data structure, without the need for a named, mutable Var. Clojure’s multimethods and all related functions could trivially be reimplemented in terms of a dispatch-map and an atom (edit: and now are!).
One use for a dispatch-map as a value is to store them within some other data
structure, without breaking the value guarantees of the enclosing data
structure. In my case, I’ve got a dispatch-map of data types to their GUI
representations. In a hierarchical definition of a GUI, each node can have a
:templates key which is a (dispatch-map class)
. If you want to render a
(Person.)
inside a list box, you can rely on automatic dispatch by type to find
the appropriate template: Simply walk up the GUI hierarchy and look in the
:templates map. Thanks to the powerful dispatch functionality, this will also
work if you have an (Employee.)
too!
Comments
tgoossens said…
Doesn’t one restrict himself then. What to do when you have a new type that you need to get working with the existing code? You cannot add any new methods. Its a neat idea and I’m sure you can use it for a lot of stuff. But I think – if my previous statement is correct – that the advantage of having it as a value doesn’t compensate for losing the ability to extend (which is basically what you want to do to solve the expression problem right?)
Brandon Bloom said…
You cannot add any new methods.
If that were true, you couldn’t add any new key value pairs to an immutable map…
the advantage of having it as a value doesn't compensate for losing the ability to extend
You’re not losing your ability to extend, you’re simply shifting it’s responsibility elsewhere.
Just put your dispatch-map in an atom, and you’ve basically got a multimethod.  The goal of dispatch-map is to decomplect dispatch from state.
Consider, for example, if I had two separate multimethods (call them f and g) and wanted to add a method to both atomically. With a multimethod, you would have to (locking xx (defmethod f …) (defmethod g …)) when you could instead (swap! yy #(–> (assoc-in [:x a] …) (assoc-in [:y a] …)))
tgoossens said…
Ok cool. I think that now I get what you were trying to achieve. Thanks for the explanation!
Paul Stadig said…
Conceptually, an atom and a dispatch-map could replace multimethods. It might be possible with multimethods, since they are so slow anyway. However, there could be performance issues.
I did some similar experiments trying to extract type based dispatch from protocol functions. I started with an atom and a dispatch table, and it turned out to be pretty slow.
Brandon Bloom said…
“Slow” is a relative term. Surely multimethods are slower than protocol dispatch. And protocol dispatch is surely slower than direct dispatch.
However, each yields an additional level of indirection for an additional abstraction need. Direct dispatch offers no abstraction. Protocol dispatch offers abstraction by type. Multimethods offer arbitrary dispatch with respect to a directed acyclic graph. In theory, you could also create a predicate-dispatch-map, which would allow dispatch with respect to an arbitrary decision tree.
With each level of abstraction, you gain a little more flexibility and dynamism at the cost of a little more performance. However, if you can statically determine a dispatch value, you can eliminate those performance costs at compile time. That’s likely not a worthwhile exercise, though, since dynamism is often the whole point of that level of abstraction.
In the case of both multimethods and my dispatch-maps, dispatch values are memoized. Subsequent calls given the same dispatch key do not require traversing the hierarchy to find a “best” match. The result is that the amortized cost of a lookup is the cost of the dispatch-fn plus the cost of one tree lookup. That’s quite reasonable in my mind. December 14, 2012 at 1:26 PM


Welcome to Forums For You!
Available forums:
There are no forums created yet.
Log in as admin to create new forums or manage existing forums.


Page is under development, Click Here to go back the home page.
No blog posts yet!
Do you want to play, Click Here to play frogger. Note that it does not work on touch screes, arrows are required! Sorry!
Muhanad Rabie
Front End Developer
Los Angeles based Front-end web developer who strives to show his love for the internet in his work. A self learner and a part time teacher, who loves to learn new programming and cutting edge web technologies to create amazing and fruitful web experiences. I'm also a Mooc enthusiast with special interest in the field of education. I truly believe that coding is a super power that anyone can acquire. In my spare time chances are you will find me in TED website.
Key Skills
- {{item}}
{{item.title}}
{{item.level}}
{{item.description}}


This product is a gentle and nourishing way to ensure soft, shiny, tangle and frizz-free hair, wash after wash! It contains natural products such as Coconut Oil that is rich in vitamins and antioxidants to replenish lost oils and protect hair from further damage. Hibiscus Flower Extract smooths and soothes hair while Neem Oil imparts a brilliant shine to those adorable curls.
This product helps to alleviate flaking and chronically dry, irritated scalp. Omega-3 fatty acids found in Flaxseed deliver effective nourishment to strands, encouraging healthier hair growth. The penetrating natural oils help to improve overall scalp health.
This nutritive, low-lather collection leaves hair and skin clean and smelling amazing. Flaxseed and Avocado Oils help soothe and calm skin irritations and blueberries are rich in antioxidants and Vitamins A, B & C, nourishing dry hair and skin.
This is an anti-frizz formula that helps curls, waves and twists stay smooth and springy. Enriched with coconut oil, shea butter, and olive oil, the custard elongates and gives curls long-lasting definition. This custard helps leave hair feeling super soft to the touch with no sticky, crunchy feel.
This rich and creamy sulfate free cleanser gently cleanses your curls, hydrates, and conditions the hair all in one step! Produces a mild, gentle lather, as it is sulfate (detergent) free. Infused with Carrot Seed oil, Horse Chestnut, Sage Leaf and Arnica Montana Flower Extract.
This Shea Moisture Smoothie is a lightweight, multi-functional styling smoothie that defines waves and curls. It features specially blended moisturizing Mango Butter and Carrot Oil to nourish and strengthen hair while protecting against breakage.


Python is often criticized -- as much from within as without -- for its proliferation of web frameworks. And yes, there's a lot -- and the list on that Wiki doesn't even cover them all, or account for the miniature frameworks built into applications. For instance, Leonardo and PyPI each have ad hoc frameworks, just to give two examples.
People suggest different ways of "solving" this problem of diversity, and say that this is the reason Python isn't as popular for web programming as PHP or Java or some other language. But I think it's time we just get over it -- the "problem" can't be solved. Java and PHP both have lots of frameworks, just like Python; this is simply the inevitable result of a diverse use base, and there's simply no way to stifle diversity and reimplementation in an open source community. Instead of reducing the options, we should work on handling the situation we have, of enabling a multitude of options instead of just complaining about it.
What does that mean?
We don't need some Killer Framework To Rule Them All -- we should work on an army of frameworks instead of a single Goliath.
The obvious way to do this is with WSGI. So far my experience with using other people's WSGI-enabled applications (or applying WSGI changes myself) has been quite successful -- when you follow the spec things Just Work.
But it shouldn't stop with simple WSGI backends to current frameworks (even if that's the right place to start). We should start pushing functionality deeper into the WSGI stack as middleware, and providing fine-grained WSGI applications that can be usefully integrated into other applications.
I think Python has a unique opportunity here:
Instead of wishing Python web programming was more like language X, we have the opportunity to do something new. We can turn this perceived flaw of diversity into a real benefit.
This isn't innovative like a whiz-bang new feature, and it's not new like proprietary-world new. This is the kind of innovation open source has been good at; integration, making things work together in new ways, realizing the benefits of distributed development. This is real innovation, it's just not innovation that the proprietary world tends to pay attention to. But working programmers know the value of this work.
This is what I've been working on in Paste; but an integration framework is only as good as the number of things that are integrated. I could use more help; simply using Paste is help. So please, the project needs more eyes and more diversity. And it matters.
While I agree somewhat that the sheer number of frameworks isn't necessarily a problem, I don't sense lock-in or incompatibility as being a huge stumbling block for many. I still think it's a business-like concern over support (i.e. documentation, books (eventually) and number of other users of the software) that is most people's concern.
"Am I going to build our department intranet in this framework and then it'll be dead by the time I'm done?" Sure people have the source, but in many cases not the time or skills to evolve and improve a framework like a community of users.
This is one thing that has drastically helped R*ils. As many similar projects do, they have a smaller core of developers who are dang good, and a much larger orbit of others -- designers, general webmonkeys, occasional programmers, beginners, etc. Many Python projects seem to get stuck at the small group of good devs - and never make it to the "attracting a crowd" part. Many possible reasons, some valid, some junk, but I still think this is the magic [but mundane] step to increasing visibility (https://ianbicking.org/why-web-programming-matters-most.html).
Eventually, a Python framework will show up in a nice package, with a non-PythonGuru friendly face and crowd (lesser mortals aren't scared away by the high priests on the project), and start attracting much more attention. Maybe Mssr Holovaty's package, maybe not (haven't seen it!). But I think once that (inevitably) happens, it will set the terms. Sorta like how the IMG tag came about maybe.
That said, if it happens on a shared spec like WSGI and your other efforts, that's even better. But I suspect that will be resolved by a large-visibility project choosing to implement it rather than the project needing to for its own success. i.e., top-down as opposed to bottom-up. Just missing the obvious top right now...
While I agree somewhat that the sheer number of frameworks isn't necessarily a problem, I don't sense lock-in or incompatibility as being a huge stumbling block for many. I still think it's a business-like concern over support (i.e. documentation, books (eventually) and number of other users of the software) that is most people's concern.If you can switch frameworks reasonably easily (and incrementally), then you can follow support and popularity. That's why I think lock in is a big problem. That said, in practice lock in isn't terrible right now, with one notable exception (that starts with a Z), but it's still more than it should be.
That said, if it happens on a shared spec like WSGI and your other efforts, that's even better. But I suspect that will be resolved by a large-visibility project choosing to implement it rather than the project needing to for its own success. i.e., top-down as opposed to bottom-up. Just missing the obvious top right now...I think (?) that Zope 3 probably already runs on WSGI. When the Twisted people asked Jim Fulton what it would take to get them to use Twisted instead of their Medusa fork, he asked them to do it via WSGI. Twisted web2 (which had a 0.1 release recently) included native WSGI support, and Zope 3 should at least come along soon. I doubt Zope 2 would be that hard either, though what I'd really like is a Zope 2 WSGI Server Product, so that you could run WSGI applications under Zope. Really I should just stop talking about it and write it, because it shouldn't be that hard.
# Ian Bicking
I should expand on the importance of being able to switch:
An environment where people can move from one framework to another will allow a real Darwinian process, and the emergence of a smaller set of "winners". Right now frameworks linger on forever, because there's no honest way for them to die. Either the developers abandon their users -- many of whom are often clients who trusted the developer's original choice of framework -- or the project keeps going and further development continues on it. Neither is good; either you are bad to your customers, or you create a partisan environment where each group of developers works in isolation to create the same set of features in their different frameworks.
The coupling of typical frameworks makes this worse. It's hard to be a polished framework when you have to implement a large number of features. As a result, frameworks typically implement a few features well, and some features poorly. As a result the selection process is haphazard, because you have to decide which features are important to you (and you don't really know), and you have to accept compromises in other features. With a decoupled stack, you can choose the best piece for each level of that stack. Sometimes there will still be vague choices -- different valid quality implementations, which appeal to different segments. But I think at each level there will arise a small set of choices, each with real reasons for existing even in the presence of other implementations.
# Ian Bicking
You are of course right on the huge value of being able to switch - or "evolve away" from a specific framework. As seen in the Java world with some people moving away from Struts to more recent setups like Spring, JSF, [today's new favorite], etc., but not needing to move it all at once.
I guess I was loosely speaking more so of the possible reasons for thriving/dying of contenders. Most likely both parts are needed: not being locked-in at a lower level will allow more dynamism in the upper levels, which should lead to a few "obvious choices" as you point out [and I tried to point out as needed to really expand the visibility of pyweb stuff].
Perhaps akin to having your living room furniture bolted down and/or integrated into your flooring - requiring tearing up the floor to change things [current scenario], and having all your furniture on wheels on a nice smooth floor - easy rearrangement [planned]. Alright I'll stop killing analogies now...
Whenever I hear the word "framework" my alarm bells ring. And I think that's the case with many people in IT.
But sometimes it does make sense to us a framework.
Choosing a (web) framework means taking risks. (Risk of "wrong" web framework selection, risk of steep learning curve, etc.) The smaller the choice the easier is the selection.
To be on the safe side, many people want to go mainstream. But there is no Python web framework mainstream. Sigh.
In order to be successful and survive, frameworks need a critical mass of users and developers. I think the diversity of Python web frameworks prevents one of those to get the critical mass. (I would say that Rails reached such a critical mass.)
As long as none of the Python web frameworks reaches such critical mass, they can't profit from self-energising (positive feedback) effects.
# Bishi
I know people are wary of frameworks, and I am too. But to clarify the discussion, "framework" can mean two things:
- A set of conventions.
- A library that tries to generalize logic.
The first is the natural result of dealing with a specific domain. This is why all web applications use a framework, even if it's a custom framework for the application. This set of conventions needs to be sufficient, as well -- the standard cgi module isn't sufficient, so if you use it you'll still end up creating a framework if your application is very large or general at all. And even that module is a mini-framework -- just not a very good mini-framework.
There's a real overhead to conventions, so if a framework is just (1) then it's still a problem. There's new words, new constructs, new interfaces, and those tend to infuse the code that uses a framework. If they don't, if those concepts are internal to the library, then it's not very framework-like. But it can't be helped sometime, you can only hope you use terminology that is clear, minimal (but sufficient), and maps well to the domain, and is conventional. Custom frameworks are most minimal, but least conventional, and tend to embody many nonconventional ideas of the application author.
The second -- generalizing logic -- is much more dangerous, though often just as necessary. For instance, if you didn't generalize logic a web application might start with:
if PATH_INFO.startswith('/contact'): import contact_form contact_form.run() elif PATH_INFO.startswith('/article') and PATH_INFO.endswith('/view'): import article_view article_view.run()And so on. Because a simple thing like URL parsing is very logic-heavy. And if you use something like SimpleHTTPServer, you'll end up writing exactly that code. Or you'll end up writing code that imports modules and does path matching generally, moving that "code" into "data" (a URL mapping or an algorithm for resolving URLs). Then you've created your own logic-generalizing framework.
In this case you hope the framework is minimal and transparent, and follows several important rules (which I have in my head and somewhere on disk, but I haven't written down on this blog).
Paste has a little of both kinds of framework, and leaves a bunch up to frameworks that run on top of it. This causes problems, but I can only say that I think hard about the issues and I'm designing Paste with these issues in mind. Decoupling makes a framework more minimal, because it is locally-understandable, and Paste is all about decoupling. A common infrastructure encourages convention. And a wide base demands that the domain be well covered.
# Ian Bicking
> Adopting a framework is less commitment, and moving to a different framework no longer requires anything like a full rewrite.
The idea of switching frameworks easily just doesn't make sense to me. For the sake of this comment, I think a framework has two parts:
- A framework lays out a set of interfaces that people can plug into. When people choose Aquarium, Aquarium lets them swap out Web servers, how they do their URLs, how they do their sessions, etc. All of this is tied to using simple API's that Aquarium provides, and then swapping in new pieces that implement those API's. Those API's are fixed so that what implements those API's can change. You can't have the backend and the API's changing at the same time, nor should you need to.
- A framework often lays down a methodology for solving a domain of problems. For instance, Aquarium lays down the way I think many Web applications should be developed. For instance, it distinguishes controllers from views. Changing from having controllers and views to something else, such as having just views and other stuff (like Zope) can never be easy. It requires a rewrite.
So if you want to change frameworks all the time, the API's have to be overly simple and it can't suggest a methodology. What's the point? ;) You're better off just providing a library for whatever real functionality you provide and not calling it a framework at all.
(That's just my $0.02. Keep up the good work :) )


23.3 Parsing XML with DOM
SAX parsing
does not build any structure in memory to represent the XML document.
This makes SAX fast and highly scalable, as your application builds
exactly as little or as much in-memory structure as needed for its
specific tasks. However, for particularly complicated processing
tasks involving reasonably small XML documents, you may prefer to let
the library build in-memory structures that represent the whole XML
document, and then traverse those structures. The XML standards
describe the DOM (Document Object Model) for XML. A DOM object
represents an XML document as a tree whose root is the
document object, while other nodes correspond to
elements, text contents, element attributes, and so
on.
The Python standard library supplies a minimal implementation of the
XML DOM standard, xml.dom.minidom.
minidom builds everything up in memory, with the
typical pros and cons of the DOM approach to parsing. The Python
standard library also supplies a different DOM-like approach in
module xml.dom.pulldom. pulldom
occupies an interesting middle ground between SAX and DOM, presenting
the stream of parsing events as a Python iterator object so that you
do not code callbacks, but rather loop over the events and examine
each event to see if it's of interest. When you do
find an event of interest to your application, you can ask
pulldom to build the DOM subtree rooted in that
event's node by calling method
expandNode, and then work with that subtree as you
would in minidom. Paul Prescod,
pulldom's author and XML and
Python expert, describes the net result as "80% of
the performance of SAX, 80% of the convenience of
DOM." Other DOM parsers are part of the PyXML and
4Suite extension packages, mentioned at the start of this chapter.
23.3.1 The xml.dom Package
The xml.dom package
supplies exception class DOMException and
subclasses of it to support fine-grained exception handling.
xml.dom also supplies a class
Node, typically used as a base class for all nodes
by DOM implementations. Class Node only supplies
constant attributes giving the codes for node types, such as
ELEMENT_NODE for elements,
ATTRIBUTE_NODE for attributes, and so on.
xml.dom also supplies constant module attributes
with the URIs of important namespaces:
XML_NAMESPACE, XMLNS_NAMESPACE,
XHTML_NAMESPACE, and
EMPTY_NAMESPACE.
23.3.2 The xml.dom.minidom Module
The xml.dom.minidom
module supplies two functions.
file is a filename or a file-like object
open for reading, containing an XML document.
parser, if given, is an instance of a SAX
parser class; otherwise, parse generates a default
SAX parser by calling xml.sax.make_parser( ).
parse returns a minidom
document object instance representing the given XML document.
parseString(string,parser=None)
|
|
Like parse, except that
string is the XML document in string form.
xml.dom.minidom also supplies many classes as
specified by the XML DOM standard. Almost all of these classes
subclass Node. Class Node
supplies the methods and attributes that all kinds of nodes have in
common. A notable class of module xml.dom.minidom
that is not a subclass of Node is
AttributeList, identified in the DOM standard as
NamedNodeMap, which is a mapping that collects the
attributes of a node of class
Element.
For methods and attributes related to changing and creating XML
documents, see Section 23.4 later in this chapter. Here, I present the
classes, methods, and attributes that you use most often when
traversing a DOM tree without changes, normally after the tree has
been built by parsing an XML document. For concreteness and
simplicity, I mention Python classes. However, the DOM specifications
deal strictly with abstract interfaces, never with concrete classes.
Your code must never deal with the class objects directly, only with
instances of those classes. Do not type-test nodes (for example,
don't use isinstance on them) and
do not instantiate node classes directly (rather, use the factory
methods covered later in Section 23.4). This is good Python
practice in general, but it's particularly important
here.
<IP_ADDRESS> Node objects
Each node n
in the DOM tree is an instance of some subclass of
Node; therefore n
supplies all attributes and methods that Node
supplies, with appropriate overriding implementations if needed. The
most frequently used methods and attributes are as follows.
The
n.attributes attribute
is either None or an
AttributeList instance with all attributes of
n.
The
n.childNodes attribute
is a list of all nodes that are children of
n, possibly an empty list.
The
n.firstChild attribute
is None when
n.childNodes is empty,
otherwise like
n.childNodes[0].
Like
len(n.childNodes)!=0,
but possibly faster.
True
when n and
other refer to the same DOM node,
otherwise False. Do not use the normal Python
idiom n is
other: a Python DOM implementation is free
to generate multiple Node instances that refer to
the same DOM node. Therefore, to check the identity of DOM node
references, always and exclusively use method
isSameNode.
The
n.lastChild attribute
is None when
n.childNodes is empty,
otherwise like
n.childNodes[-1].
The
n.localName attribute
is the local part of n's
qualified name (relevant when namespaces are involved).
The
n.namespaceURI
attribute is None when
n's qualified name has no
namespace part, otherwise the namespace's URI.
The
n.nextSibling attribute
is None when n is the
last child of n's parent,
otherwise the next child of
n's parent.
The
n.nodeName attribute is
n's name string. The
string is a node-specific name when that makes sense for
n's node type (e.g., the
tag name when n is an
Element), otherwise a string starting with
'#'.
The
n.nodeType attribute is
n's type code, an integer
that is one of the constant attributes of class
Node.
The
n.nodeValue attribute
is None when n has no
value (e.g., when n is an
Element), otherwise
n's value (e.g., the text
content when n is an instance of class
Text).
Normalizes the entire subtree rooted at
n, merging adjacent
Text nodes. Parsing may separate ranges of text in
the XML document into arbitrary chunks; normalize
ensures that text ranges remain separate only when there is markup
between them.
The
n.ownerDocument
attribute is the Document instance that contains
n.
The
n.parentNode attribute
is n's parent node in the
DOM tree, or None for attribute nodes and nodes
not in the tree.
The
n.prefix attribute is
None when
n's qualified name has no
namespace prefix, otherwise the namespace prefix. Note that a name
may have a namespace even if it has no namespace prefix.
The
n.previousSibling
attribute is None when
n is the first child of
n's parent, otherwise the
previous child of n's
parent.
<IP_ADDRESS> Attr objects
The Attr class is a subclass of
Node that represents an attribute of an
Element. Besides attributes and methods of class
Node, an instance a of
Attr supplies the following
attributes.
The
a.ownerElement
attribute is the Element instance of which
a is an attribute.
The
a.specified attribute
is true if a was explicitly specified in
the document, false if obtained by default.
<IP_ADDRESS> Document objects
The
Document class is a subclass of
Node whose instances are returned by the
parse and parseString functions
of module xml.dom.minidom. All nodes in the
document refer to the same Document node as their
ownerDocument attribute. To check this, you must
use the isSameNode method, not Python identity
checking (operator is). Besides the attributes and
methods of class Node,
d supplies the following attributes and
methods.
The
d.doctype attribute is
the DocumentType instance corresponding to
d's DTD. This attribute
comes directly from the !DOCTYPE declaration in
d's XML source.
The
d.documentElement
attribute is the Element instance corresponding to
d's root element.
d.getElementById(elementId)
|
|
Returns the Element
instance within the document that has the given ID (what element
attributes are IDs is specified by the DTD), or
None if there is no such instance (or the
underlying parser does not supply ID information).
d.getElementsByTagName(tagName)
|
|
Returns the list of Element instances within the
document whose tag equals string tagName,
in the same order as in the parsed XML document. May be the empty
list. When name is '*',
returns the list of all Element instances within
the document, with any tag.
d.getElementsByTagNameNS(namespaceURI,localName)
|
|
Returns the list of Element instances within the
document with the given namespaceURI and
localName, in the order found in the XML
document. May be the empty list. A value of '*'
for namespaceURI,
localName, or both matches all values of
the corresponding field.
<IP_ADDRESS> Element objects
The
Element class is a subclass of
Node that represents tagged elements. Besides
attributes and methods of Node, an instance
e of Element supplies
the following methods.
Returns the value of
e's attribute with the
given name. Returns the empty string
'' if e has no
attribute with the given name.
e.getAttributeNS(namespaceURI,localName)
|
|
Returns the value of
e's attribute with the
given namespaceURI and
localName.
Returns the Attr
instance that is e's
attribute with the given name, or
None if no attribute with that name is among
e's attributes.
e.getAttributeNodeNS(namespaceURI,localName)
|
|
Returns the Attr
instance that is e's
attribute with the given namespaceURI and
localName, or None if
no such attribute is among
e's attributes.
e.getElementsByTagName(tagName)
|
|
Returns the list of
Element instances within the subtree rooted at
e whose tag equals string
tagName, in the same order as in the XML
document. e is included in the list that
getElementsbyTagName returns if
e's tag equals
tagName.
getElementsbyTagName may return the empty list
when no node in the subtree rooted at e
has a tag equal to tagName. When
tagName is '*',
getElementsbyTagName returns the list of all
Element instances within the subtree, with any
tag, including e.
e.getElementsByTagNameNS(namespaceURI,localName)
|
|
Returns the list of
Element instances within the subtree rooted at
e, with the given
namespaceURI and
localname, in the same order as in the XML
document. A value of '*' for
namespaceURI,
localname, or both matches all values of
the corresponding field. The list may include
e or may be empty, just as for method
getElementsByTagName.
True if and only if
e has an attribute with the given
name. If the underlying parser extracts
the relevant information from the DTD,
hasAttribute is also true for attributes of
e that have a default value, even when
they are not explicitly specified.
e.hasAttributeNS(namespaceURI,localName)
|
|
True if and only if e has an attribute
with the given namespaceURI and
localName. Same as method
hasAttribute regarding attributes with default
values from the DTD.
23.3.3 Parsing XHTML with xml.dom.minidom
The following example uses
xml.dom.minidom to perform the same task as in the
previous example for xml.sax, fetching a page from
the Web with urllib, parsing it, and outputting
the hyperlinks:
import xml.dom.minidom, urllib, urlparse
f = urllib.urlopen('http://www.w3.org/MarkUp/')
doc = xml.dom.minidom.parse(f)
as = doc.getElementsByTagName('a')
seen = {}
for a in as:
value = a.getAttribute('href')
if value and value not in seen:
seen[value] = True
pieces = urlparse.urlparse(value)
if pieces[0] == 'http' and pieces[1]!='www.w3.org':
print urlparse.urlunparse(pieces)
In this example, we get the list of all elements with tag
'a', and the relevant attribute, if any, for each
of them. We then work in the usual way with the
attribute's value.
23.3.4 The xml.dom.pulldom Module
The
xml.dom.pulldom module supplies two functions.
file is a filename or a file-like object
open for reading, containing an XML document.
parser, if given, is an instance of a SAX
parser class; otherwise parse generates a default
SAX parser by calling xml.sax.make_parser( ).
parse returns a pulldom event
stream instance representing the given XML document.
parseString(string,parser=None)
|
|
Like parse, except that
string is the XML document in string form.
xml.dom.pulldom also supplies class
DOMEventStream, an iterator whose items are pairs
(event,node),
where event is a string giving the event
type, and node is an instance of an
appropriate subclass of class Node. The possible
values for event are constant uppercase
strings that are also available as constant attributes of module
xml.dom.pulldom with the same names:
CHARACTERS, COMMENT,
END_DOCUMENT, END_ELEMENT,
IGNORABLE_WHITESPACE,
PROCESSING_INSTRUCTION,
START_DOCUMENT, and
START_ELEMENT.
An instance d of class
DOMEventStream supplies one other important
method.
node must be the latest instance of
Node so far returned by iterating on
d, i.e., the instance of
Node returned by the latest call to
d.next( ).
expandNode processes that part of the XML document
stream that corresponds to the subtree rooted at
node, ensuring that you can then access
the subtree with the usual minidom approach.
d iterates on itself for the purpose so
that after calling expandNode, the next call to
next continues right after the subtree thus
expanded.
23.3.5 Parsing XHTML with xml.dom.pulldom
The following
example uses xml.dom.pulldom to perform the same
task as our previous examples, fetching a page from the Web with
urllib, parsing it, and outputting the hyperlinks:
import xml.dom.pulldom, urllib, urlparse
f = urllib.urlopen('http://www.w3.org/MarkUp/')
doc = xml.dom.pulldom.parse(f)
seen = {}
for event, node in doc:
if event=='START_ELEMENT' and node.nodeName=='a':
doc.expandNode(node)
value = node.getAttribute('href')
if value and value not in seen:
seen[value] = True
pieces = urlparse.urlparse(value)
if pieces[0] == 'http' and pieces[1]!='www.w3.org':
print urlparse.urlunparse(pieces)
In this example, we select only elements with tag
'a'. For each of them we request full expansion,
and then proceed just like in the minidom example
(i.e., we get the relevant attribute, if any, then work in the usual
way with the attribute's value). The expansion is in
fact not necessary in this specific case, since we do not need to
work with the subtree rooted in each element with tag
'a', just with the attributes, and attributes can
be accessed without calling expandNode. Therefore,
this example works just as well if you change the call to
doc.expandNode into a comment. However, I put the
expandNode call in the example to show how this
crucial method of pulldom is normally used in
context.
|


MY NEIGHBOR TOTORO (TONARI NO TOTARO) A film review by Chris Meadows Copyright 1995 Chris Meadows
Produced, Directed, and Written by Hayao Miyazaki 1988 (1993, American release), color, 87 minutes
Available on videocassette, ~$20
My Rating: 9 out of a possible 10
I'm an anime fan. Yes, that's right, one of those people who religiously collects Japanese animation by methods of sometimes dubious legality, huddles in dark screening rooms at science-fiction conventions to get my "fix," complains prodigiously about dubs (especially those from Streamline), and is probably looked upon rather oddly by most of the people I know because of it.
As I said, I tend to complain prodigiously about dubs, especially those done by Streamline. As such, it's probably more than a little surprising to you that I'm rating this particular Streamline dub so highly. I know it's *damn* surprising to me.
You see, Streamline has this annoying little habit of *changing* the lines that they're supposed to be dubbing. The most notable example that comes to mind is when Goemon the samurai cuts Lupin's burning clothes off of him in the movie LUPIN III: CASTLE OF CAGLIOSTRO. In the original, he says afterward, "Once again, I've cut a worthless object." In the Streamline dub, he says, "Should've worn an asbestos suit." And the president of Streamline, Carl Macek, has stated that he will never subtitle any of his films. Purist that I am, I find this kind of thing totally unacceptable, so I was, to say the least, highly dubious of Totoro.
What made the CAGLIOSTRO dub all the more disappointing was the fact that the movie was one of my favorites in the subtitled format. It was a Hayao Miyazaki film, and Miyazaki is my favorite anime creator.  It is sadly ironic that Streamline got its hands on most of these, and thus no "decent" commercial version will ever be produced.
Anyway, enough Streamline bashing; that isn't the point of this review. As I've said, I was skeptical of TOTORO, even though some friends and acquaintances told me it was quite good. However, since Miyazaki *is* my favorite director, I knew I would eventually have to see it. But as my concession to myself before seeing a Streamline dub (an act which tends to make me come away feeling rather dirty), I decided to obtain and view the fan-subtitled version first. Thus, I watched the TOTORO fansub one night and the TOTORO commercial dubbed release the next.
Even though TOTORO is touted as a children's movie (and a very good children's movie it is, too), is is a film that will likely enthrall and at the very least not bore (or, for that matter, nauseate--Barney, anyone?) any grown-ups who watch it too. The story is fairly simple--two young girls and their father move into a house in the Japanese countryside to be closer to their hospitalized mother, and the girls meet and befriend the magical creatures that live in the forest nearby. But there's more to this film than that.  It's not my favorite Miyazaki story, but I couldn't help but be entranced by its simple charm all the same. Miyazaki always does that to me.
One thing about Miyazaki is that he likes to make references to other films. For example, in both LAPUTA: CASTLE IN THE SKY and an episode of the "Lupin" TV series that he directed, a robot is featured that looks remarkably similar to one from a 1930s Fleischer Superman short. In MY NEIGHBOR TOTORO there are references to at least a couple of children's movies--namely, MARY POPPINS and ALICE IN WONDERLAND. I had to smile.
As I've said, I was quite skeptical up to the moment when I put the dub into the VCR and pressed play. My skepticism began its immediate decline when the opening theme began playing. As this is a children's movie, it was to be expected that the music would be translated into English, and I was half-expecting some sort of stupid kiddie song that would be entirely unrelated to the spirit of the original. But as soon as the theme began, my jaw dropped, for they had somehow managed to translate that song almost *excatly*. The English singer even sounded like the original Japanese one!
And it was thus throughout the entire film. Not only were the translations nearly flawless but even the voice-acting was dead-on! My friend had said to me that the voices in the English version sounded just like the voices in the Japanese version. And they did! The translations were 98% accurate--even trivial lines that weren't important to the story were often rendered correctly. By the time the closing credits had rolled, I had realized that my fansubbed copy of this movie was going to be gathering a lot of dust.
A brief summary of the most noticeable differences between the original and the dubbed versions: The opening and closing songs are in English, as I've said. The minor elements of Buddhism (the religion usually depicted in anime) have been removed: where in the original the older sister prays at a shrine to let them take shelter from the rain there, she now asks, "Would it be all right if we stay here?"; where an old lady was chanting a prayer to Buddha she is now murmuring in the style of someone praying under her breath. The film has been pan-and-scanned, as well.
One thing which particularly relieves me is that Carl Macek didn't pull any of his usual "hide-the-kanji-at-all-costs" tricks which so often make the opening credits of movies he dubs look like crud. (In order to hide the Japanese symbols in the Castle of Cagliostro opening credits, for example, he slowed down the opening animation and reframed parts of the picture, and it looked utterly disgusting.) In the scenes where a bus's sign changes to indicate its destination, he dubbed in a voice (provided, so I'm told, by Carl himself) that said, "Next stop..." In one instance a subtitle is provided for translation. As many instances of kanji as there are in this film, I'm glad he didn't try to hide them this time.
Another thing which relieves me is that none of the names are changed. All the original Japanese names are still used, and even pronounced properly, as far as I know (I especially like the way the older sister pronounces "Totoro"). This is one more element that adds to the general Japanese ambiance of this movie. It makes me feel as though the characters actually *are* Japanese, but I just happen to be able to understand them for some mysterious reason. Very few dubs have ever done that for me.
And now I've reached the point where, in summing up, I'm probably supposed to draw upon those phrases that have become cliches by virtue of repeated use in magazine movie reviews and inclusion on the backs of video boxes. Things like "This is a magical film for all ages," for example. But I'm not trying to advertise this movie; it's not like I'm going to make money off of it or anything. So, I'll just sum up with a few observations, instead.
This is one of very few dubs that I would not feel ashamed to show to other people. It maintains the integrity of the original almost to the last detail. The film itself is easily comparable to some of Disney's best, with an attention to detail that Disney sometimes lacks.
If you're looking for something you can show the kiddies that won't have them karate-chopping around the house afterward, get MY NEIGHBOR TOTORO.  If nothing else, rental will only cost a buck or two, and trust me--the experience is more than worth it.
(This review is copyright 1995 by Christopher E. Meadows. Distribution is okay as long as it's not for profit and this notice remains intact. Distribution on CD-ROM is verboten without Chris's permission, however.)
-- Chris Meadows<EMAIL_ADDRESS><EMAIL_ADDRESS>http://www.halcyon.com/superguy/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Deontay Wilder vs Luis Ortiz rematch: When is fight, UK start time, how can I watch it, TV channel, undercard, odds
Everything you need to know as the WBC champion defends his title against the Cuban veteran in Las Vegas
by Tom KershawWorld heavyweight champion Deontay Wilder defends his WBC title in a rematch against Luis Ortiz in Las Vegas this weekend.
The undefeated American came within seconds of being stopped by the Cuban veteran in the pair’s first bout before rallying to win via TKO.
Wilder has since knocked out Dominic Breazeale and then retained his belt in a controversial draw against Tyson Fury.
If Wilder defeats Ortiz, he’s expected to rematch Fury in February.
Here is everything you need to know about the fight:
When is the fight?
The fight is scheduled to take place on Saturday 23 November at the MGM Grand in Las Vegas.
What time will the fight start in the UK?
The ringwalks are expected to begin around 5am UK time on Sunday.
How can I watch it?
The fight will be broadcast live on Sky Sports Action with coverage starting at 2am on Sunday.
What are their records?
Wilder is undefeated in 42 professional fights, winning 40 by knockout.
Ortiz’s record boasts 31 wins, 26 of which ended by knockout, with his only loss coming at the hands of Wilder.
Who is on the undercard?
Luis Nery vs Emmanuel Rodriguez (bantamweight)
Brandon Figueroa vs Julio Ceja (super bantamweight)
Leo Santa Cruz vs Miguel Flores (super featherweight)
Leduan Barthelemy vs Eduardo Ramirez (super featherweight)
Jerry Perez vs Mark John Yap (super featherweight)
Viktor Slavinskyi vs Rigoberto Hermosillo (super featherweight)
Arnold Alejandro vs TBA (lightweight)
Omar Juarez vs Kevin Shacks (super lightweight)
Jose Manuel Gomesz vs Daniel Placeres (super featherweight)
Angel Alejanadro vs TBA (featherweight)
Shon Mondragon vs TBA (super bantamweight)
Vito Mielnicki Jr vs Marklin Bailey (welterweight)
Marsellos Wilder vs Dustin Long (cruiserweight)
What are the odds?
Wilder – 1/6
Ortiz – 9/2
Draw – 25/1


Rangers get an early jump on Friday's toy drive
It's in support of the Grand River Hospital Foundation
by KitchenerToday StaffNEWS RELEASE
KITCHENER RANGERS
*************************
The Wawanesa Insurance Toy Drive in support of the Grand River Hospital Foundation (GRHF) is this Friday!
Since the players will be on the ice looking for a win against the rival London Knights, co-captains Riley Damiani and Greg Meireles along with Jonathan Yantsis wanted to kick-start the collection early.
On the team’s behalf, they made a donation this afternoon to Paul Murphy, Sr. Business Development Representative with Wawanesa Mutual Insurance Company.
You can also join our players and place a smile on a child’s face this holiday season by donating a new and unwrapped toy or making a cash donation at the game this Friday at 7:30pm.
The Wawanesa event team will be in the concourse collecting toy and cash donations while also selling Wawanesa stuffed bears for $10 – which can then be donated to the toy drive. Some requested donation items include:
- Colouring, activity, and reading books
- Crayons, pencil crayons, and markers (ideally in small packages to take home)
- Bubbles, Crayola Model Magic, and Hasbro Play-Doh
- Craft kits or board games
- New small to medium-sized stuffed animals
- Tactile and fidget toys
- Small dolls or Hot Wheels/Matchbox cars
- Lego and Lego Kits
- Puzzle games
- Gift cards for emergency needs
- Gift cards for movies and music for teenage patients (Amazon, iTunes, Google Play, Cineplex etc.)
Please note that dollar store toys cannot be accepted due to the low-quality plastics not meeting health and safety standards/regulations of the hospital.
Fans attending the game will also have a chance to win a trip to the CHL Memorial Cup, presented by Kia! Contest rules can be found at wawanesa.com/toydrive
*************************


Follow these instructions below using resources identified in
the Before You Begin section
- Let's skip the very first step on your way to be me, Sergey Sabirov.
You just needed to be born in Russia to be me. As long as the time machine hasn't
been invented yet, you will not be able to go back a few years ago and convince your
parents that they need to move to Russia because life there is so much fun!
However, it is true...
- But do not give up! You definitely can successfully accomplish the second
step: become an undergraduate student at Virginia Tech in the electrical engineering
department.
*If you are already a student, please, skip this step and go to the step 3
of this section.
You need to:
- Pass all the required standards tests such as SAT.
- Send your transcripts to VT admissions office.
- Fill out the application form on VT website.
- Submit your filled out application.
- Pay application fee.
- Secure funding (or maybe you already have money). The sooner, the better.
- Wait until the university sends you the acceptance letter.
- Locate an appropriate apartment with nice roommates.
*For more information refer to: http://www.admiss.vt.edu/
- As soon as you are a student, you can register for the summer term.
In order to do so:
- Please, go to Hokie SPA located at: https://banweb.banner.vt.edu/ssb/prod/twbkwbis.P_WWWLogin.
- Register for Summer I and Summer II by following the instructions on the website.
- To find a part-time job as a computer technician, please, you need to:
- Join the listserv for engineering students (information about job openings is
often spread through listserv).
- Prepare your CV or resume.
- Contact all locally available technician centers, stores
(4Help at VT; Best Buy; PC Land etc.).
- Send out your CV or resume and wait.
- To find a Russian girlfriend/boyfriend, you just need to be lucky!
Especially, here at VT. There are just a few Russian students on campus.
However, these are tips that will increase your chances of a successful "hunt":
- Hang out on campus as much as possible.
- Try to communicate with foreign students as often as you can.
- Join "the Russian Club at VT" Facebook group to find someone cute and Russian.
- Show your interest in the Russian culture and make sure you are invited to the next Russian party.
- Be confident and smile.
- No questions about "communism", "vodka" or "evil Putin" - that's an instant turn off.
- My congratulations if you successfully finished step 5.
That was not easy! Take a deep breath, relax a little and go ahead to ask your lovely Russian speaking partner to move in together.
*This step, probably, will be much harder for females, but nothing is impossible.
- Cook a nice dinner and invite your date to your house (you can eat out somewhere at a nice place as well).
- Do not jump into this important conversation right away. Have fun and watch TV.
- Start the conversation and explain reasons why you want to live with him/her.
- Promise that you will do your best to work on your relationship.
- Be genuine!
- Hope your 6 step is accomplished, and you, guys, on your way to pack
things and move to your sweet nest together, or one of you can move in another's
partner place. Whatever your choice is, here are the instructions on how to be
technology addicted as I am:
- Follow every major news site publishing materials about technology development and its novelties.
- Go from link to link, read as much as you can.
- Do not keep an eye on time, time passes quickly, no need to take care of that.
- Employ YouTube a lot: there is a whole lot of the most interesting technology relating videos.
- If your girlfriend/boyfriend says: "It's time to get back to homework",
respond: "Just 5 more minutes". Keep replying with the same answer either until
s/he stops reminding or when it is the really time to hurry up and get back to work.
- Remember: there is never too much information about your passion.
- After staying up late, you will, obviously, be knocked down till 1-2 p.m.
When your beloved one says again: "Wake up! It's time to get back to homework",
please, follow the instruction above and reply: "Just 5 more minutes".
It works as perfect as for the example above.
- Now it is time to go out! No, you do not want to go to the Hokie House to get
a sip of the Long Island drink, while being surrounded by tipsy Hokie fellows. The best place
to go out for a technology addict is to drive to Wallops Flight Facility and see a
rocket launch. To do so:
- Use your navigator to drive to the point of interest.
- Allow yourself the least possible time. When I was driving there, I was so late
that if there had been policemen on the road, I would have got so many tickets that
my 2 month salary would not cover them all.
- Arrive there just 10 seconds before the launch.
- Run like hell to get as close as possible.
- Take your phone and start making pictures. Let your emotions rule:
scream because it is already in the air! But you are right on time!
 How would you look at them if they were you?


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import models.responses.FlashKeys @import config.GoogleFormFeedbackLinkConfig @import uk.gov.hmrc.govukfrontend.views.html.components._ @import views.helpers.Title @import views.html.components.gds._ @import views.html.components.exit_survey @import play.twirl.api.HtmlFormat @this( govukLayout: gdsMainTemplate, govukPanel : GovukPanel, govukButton: GovukButton, govukInsetText : GovukInsetText, link: link, formHelper: uk.gov.hmrc.play.views.html.helpers.FormWithCSRF, googleFormFeedbackLinkConfig: GoogleFormFeedbackLinkConfig, exitSurvey: exit_survey ) @()(implicit request: Request[_], flash: Flash, messages: Messages) @titleKey = @{ s"declaration.confirmation.${flash.get(FlashKeys.decType).getOrElse("default").toLowerCase}.title" } @lrnMessage(lrn: String) = {
@Html(messages("declaration.confirmation.leaveFeedback.text", link( id = Some("feedback-link"), text = messages("declaration.confirmation.leaveFeedback.link"), call = Call(method = "GET", url = feedbackLink), target = "_blank" )))
}@Html(messages("declaration.confirmation.info", link( id = Some("submissions-link"), text = messages("declaration.confirmation.info.link"), call = routes.SubmissionsController.displayListOfSubmissions() )))
@link( id = Some("back-to-start-link"), text = messages("declaration.confirmation.submitAnotherDeclaration"), call = routes.ChoiceController.displayPage())
@exitSurvey() }


---
layout: default
description: "Frontend Developer at BUZZWOO! Asia, Chiang Mai, Thailand. <3 Web Platform. Blogs about web and frontend toolings."
title: Frontend Developer, Chiang Mai, Thailand. <3 Web Platform.
---
Frontend
Nerd
สวัสดีครับ. My name is Armno. I am a frontend(-ish) developer at BUZZWOO! Asia, based in Chiang Mai, Thailand. I’m interested in JavaScript, Angular, and Frontend performance. This is my blog where I write about my web development experiences.
I’m also on Twitter and GitHub.


RECRUITMENT INFORMATION
Position：Flight control software engineer
Job responsibilities: (salary: negotiable)
Mainly engaged in flight control system development and algorithm debugging, need to have experience in embedded software development and the basis for mastering certain automatic control theory, for embedded flight control system is developed and the control effect of debugging
Job responsibilities:
1.responsible for the software development of flight control computer and peripherals driver
2.flight control algorithm embedded
3.to assist the aircraft control system test and analysis
Job requirements:
1.bachelor degree or above, major in electronics, computer, automation, aircraft control and related;
2.with the digital circuit, communication system, such as theoretical basis; proficient in embedded C language programming, mastery based Cortex-M core microcontroller software development; familiar with RS232 / RS485 communication interface control method; familiar with at least one kind of embedded operating system (such as UC / OS, VxWorks, UNIX, Nuttx, RTOS; at least 2 years working experience in embedded software development;
3.with aircraft control and related product software development experience is preferred


## this is the skeleton of all pages on our site - it defines the basic structure with our menus, sidebars, etc.
## by naming this file with .htm, it can't be viewed directly (urls.py only allows full .html)
## set up a StaticRenderer object to enable the CSS/JS automatic inclusion magic.
<%! from base_app import static_files %>
<% static_renderer = static_files.StaticRenderer(self) %>
Hex Photos
<%block name="head_section">
%block>
## render the css
${ static_renderer.get_template_css(request, context) }
<%block name = "menu">
%block>
<%block name = "user">
%block>
<%block name = "top_menu">
%block>
<%block name="title">
%block>
<%block name="content">
Site content goes here in sub-templates.
%block>
<%block name="footer">
%block>
## render the JS for this page (placed here at the end because browsers apparently load faster when JS is at the end)
${ static_renderer.get_template_js(request, context) }


|
Halide
12.0.0
|
Routines specific to the Halide Hexagon host-side runtime. More...
#include "HalideRuntime.h"
Go to the source code of this file.
Classes | |
| struct | halide_hexagon_power_t |
| More detailed power settings to control Hexagon. More... | |
Macros | |
| #define | HALIDE_RUNTIME_HEXAGON |
Typedefs | |
| typedef int | halide_hexagon_handle_t |
| typedef enum halide_hexagon_power_mode_t | halide_hexagon_power_mode_t |
| Power modes for Hexagon. More... | |
| typedef halide_hexagon_power_t | halide_hvx_power_perf_t |
Enumerations | |
| enum | halide_hexagon_power_mode_t { halide_hexagon_power_low = 0 , halide_hexagon_power_nominal = 1 , halide_hexagon_power_turbo = 2 , halide_hexagon_power_default = 3 , halide_hexagon_power_low_plus = 4 , halide_hexagon_power_low_2 = 5 , halide_hexagon_power_nominal_plus = 6 , halide_hvx_power_low = halide_hexagon_power_low , halide_hvx_power_nominal = halide_hexagon_power_nominal , halide_hvx_power_turbo = halide_hexagon_power_turbo , halide_hvx_power_default = halide_hexagon_power_default } |
| Power modes for Hexagon. More... | |
Functions | |
| const struct halide_device_interface_t * | halide_hexagon_device_interface () |
| bool | halide_is_hexagon_available (void *user_context) |
| Check if the Hexagon runtime (libhalide_hexagon_host.so) is available. More... | |
| int | halide_hexagon_wrap_device_handle (void *user_context, struct halide_buffer_t *buf, void *ptr, uint64_t size) |
| The device handle for Hexagon is simply a pointer and size, stored in the dev field of the halide_buffer_t. More... | |
| int | halide_hexagon_detach_device_handle (void *user_context, struct halide_buffer_t *buf) |
| Disconnect this halide_buffer_t from the device handle it was previously wrapped around. More... | |
| void * | halide_hexagon_get_device_handle (void *user_context, struct halide_buffer_t *buf) |
| Return the underlying device handle for a halide_buffer_t. More... | |
| uint64_t | halide_hexagon_get_device_size (void *user_context, struct halide_buffer_t *buf) |
| int | halide_hexagon_power_hvx_on (void *user_context) |
| Power HVX on and off. More... | |
| int | halide_hexagon_power_hvx_off (void *user_context) |
| void | halide_hexagon_power_hvx_off_as_destructor (void *user_context, void *) |
| int | halide_hexagon_set_performance_mode (void *user_context, halide_hexagon_power_mode_t mode) |
| Set a performance target for Hexagon. More... | |
| int | halide_hexagon_set_performance (void *user_context, halide_hexagon_power_t *perf) |
| int | halide_hexagon_set_thread_priority (void *user_context, int priority) |
| Set the default priority for Halide Hexagon user threads: More... | |
| int | halide_hexagon_initialize_kernels (void *user_context, void **module_ptr, const uint8_t *code, uint64_t code_size, const uint8_t *runtime, uint64_t runtime_size) |
| These are forward declared here to allow clients to override the Halide Hexagon runtime. More... | |
| int | halide_hexagon_run (void *user_context, void *module_ptr, const char *name, halide_hexagon_handle_t *function, uint64_t arg_sizes[], void *args[], int arg_flags[]) |
| void | halide_hexagon_finalize_kernels (void *user_context, void *state_ptr) |
| int | halide_hexagon_device_release (void *user_context) |
Routines specific to the Halide Hexagon host-side runtime.
Definition in file HalideRuntimeHexagonHost.h.
| #define HALIDE_RUNTIME_HEXAGON |
Definition at line 19 of file HalideRuntimeHexagonHost.h.
| typedef int halide_hexagon_handle_t |
Definition at line 21 of file HalideRuntimeHexagonHost.h.
| typedef enum halide_hexagon_power_mode_t halide_hexagon_power_mode_t |
Power modes for Hexagon.
Definition at line 107 of file HalideRuntimeHexagonHost.h.
Power modes for Hexagon.
Definition at line 66 of file HalideRuntimeHexagonHost.h.
| const struct halide_device_interface_t* halide_hexagon_device_interface | ( | ) |
| bool halide_is_hexagon_available | ( | void * | user_context | ) |
Check if the Hexagon runtime (libhalide_hexagon_host.so) is available.
If it is not, pipelines using Hexagon will fail.
| int halide_hexagon_wrap_device_handle | ( | void * | user_context, |
| struct halide_buffer_t * | buf, | ||
| void * | ptr, | ||
| uint64_t | size | ||
| ) |
The device handle for Hexagon is simply a pointer and size, stored in the dev field of the halide_buffer_t.
If the buffer is allocated in a particular way (ion_alloc), the buffer will be shared with Hexagon (not copied). The device field of the halide_buffer_t must be NULL when this routine is called. This call can fail due to running out of memory or being passed an invalid device handle. The device and host dirty bits are left unmodified.
| int halide_hexagon_detach_device_handle | ( | void * | user_context, |
| struct halide_buffer_t * | buf | ||
| ) |
Disconnect this halide_buffer_t from the device handle it was previously wrapped around.
Should only be called for a halide_buffer_t that halide_hexagon_wrap_device_handle was previously called on. Frees any storage associated with the binding of the halide_buffer_t and the device handle, but does not free the device handle. The device field of the halide_buffer_t will be NULL on return.
| void* halide_hexagon_get_device_handle | ( | void * | user_context, |
| struct halide_buffer_t * | buf | ||
| ) |
Return the underlying device handle for a halide_buffer_t.
If there is no device memory (dev field is NULL), this returns 0.
| uint64_t halide_hexagon_get_device_size | ( | void * | user_context, |
| struct halide_buffer_t * | buf | ||
| ) |
| int halide_hexagon_power_hvx_on | ( | void * | user_context | ) |
Power HVX on and off.
Calling a Halide pipeline will do this automatically on each pipeline invocation; however, it costs a small but possibly significant amount of time for short running pipelines. To avoid this cost, HVX can be powered on prior to running several pipelines, and powered off afterwards. If HVX is powered on, subsequent calls to power HVX on will be cheap.
| int halide_hexagon_power_hvx_off | ( | void * | user_context | ) |
| void halide_hexagon_power_hvx_off_as_destructor | ( | void * | user_context, |
| void * | |||
| ) |
| int halide_hexagon_set_performance_mode | ( | void * | user_context, |
| halide_hexagon_power_mode_t | mode | ||
| ) |
Set a performance target for Hexagon.
Hexagon applications can vote for the performance levels they want, which may or may not be respected by Hexagon. Applications should be careful not to leave Hexagon in a high power state for too long. These functions can significantly increase standby power consumption. Use halide_hexagon_power_default to reset performance to the default power state.
| int halide_hexagon_set_performance | ( | void * | user_context, |
| halide_hexagon_power_t * | perf | ||
| ) |
| int halide_hexagon_set_thread_priority | ( | void * | user_context, |
| int | priority | ||
| ) |
Set the default priority for Halide Hexagon user threads:
| int halide_hexagon_initialize_kernels | ( | void * | user_context, |
| void ** | module_ptr, | ||
| const uint8_t * | code, | ||
| uint64_t | code_size, | ||
| const uint8_t * | runtime, | ||
| uint64_t | runtime_size | ||
| ) |
These are forward declared here to allow clients to override the Halide Hexagon runtime.
Do not call them.
| int halide_hexagon_run | ( | void * | user_context, |
| void * | module_ptr, | ||
| const char * | name, | ||
| halide_hexagon_handle_t * | function, | ||
| uint64_t | arg_sizes[], | ||
| void * | args[], | ||
| int | arg_flags[] | ||
| ) |
| void halide_hexagon_finalize_kernels | ( | void * | user_context, |
| void * | state_ptr | ||
| ) |
| int halide_hexagon_device_release | ( | void * | user_context | ) |


Data Structure Definition¶
In the previous chapter, the ServiceProvider got the path to a crud.yml told. This is where CRUDlex gets it’s information about what tables with what fields exists in your database. We will build up a valid, small example as we continue in this chapter.
Entities¶
The first items in the crud.yml are the entities. Each entity is describing a single table with it’s fields. Let’s say we have two tables, libraries and books. So we define two entities with the same name. Note that this name is your choice, the table name of the database gets defined in a second.
library:
book:
In this case, the entities would be available under this URLs (assuming you mounted the Controller under “/crud”):
http://.../crud/library
http://.../crud/book
Now we declare the labels and the tables. The label is used for displaying links in the navigation and in some messages:
library:
label: Library
table: library
book:
label: Book
table: book
Fields¶
So far, so good. In our minimal example, a library has a name and a Book has an author, a title and the amount of pages as fields.
library:
label: Library
table: library
fields:
name:
type: text
label: Name
book:
label: Book
table: book
fields:
author:
type: text
label: Author
title:
type: text
label: Title
pages:
type: integer
label: Pages
Note that the yml keys “name”, “author” and “title” directly name the database column names. Each one has a type and a label here. The type defines the database type and the label is used in various places to display the field. In this example, only simple string types are used and an integer for the book pages.
Beside this fields, the CRUDlex MySQL implementation assumes that you have some more fields per table:
- id int(11) NOT NULL AUTO_INCREMENT: the id of each row
- created_at datetime NOT NULL: a timestamp in UTC when the row was created
- updated_at datetime NOT NULL: a timestamp in UTC when the row was the last time updated
- deleted_at datetime DEFAULT NULL: defines when this entry was deleted in UTC. CRUDlex uses a soft delete mechanism hiding all rows where this is not null
- version int(11) NOT NULL: used for optimistic locking
See the CRUDlexSample.sql in the sample project for the exact table creation.


Sign In
Home
Blog
Contact
Elijah Paminsan
Project Manager
Adam David
UI Developer
Nathaniel Mosco
Backend Developer
Todd Murphy
React II Developer
Tanner Hawkins
React II Developer
Cameron Moore
React I Developer


{% extends 'layouts/base.html' %} {% load widget_tweaks %} {% load socialaccount %} {% load crispy_forms_tags %} {% load static %} {% block content %} {% if form.errors %}
Your username and password didn't match. Please try again.
{% endif %} {% if next %} {% if user.is_authenticated %}Your account doesn't have access to this page. To proceed, please login with an account that has access.
{% else %}Please login to see this page.
{% endif %} {% endif %}


If you’re here, you might know about docker, if you don’t know about docker, please refer to the following articles, videos and slides about docker, which might capture your interest [0].
This article is not about docker, it’s more about the Co., the eCosystem around docker and dockerization of your apps, services and last but not least about bringing the DevOps style and a new way of thinking to your business.
The following list below provides an overview of the Co., the eCosystem around docker, which for sure is not complete and is intended only as a reference for my own observation and research about these systems and why the eCosystem around docker is embracing and integrating docker and how we can use and combine them together for different use cases.
So let’s have a look on this short list:
Ansible & Docker
Amazon EC2 & Docker
Apache Brooklyn & Docker
Apache Hadoop & Docker
Apache Storm & Docker
AppScale & Docker
Atomic Hosts & Docker
Chef & Docker
Clocker & Docker
Cloud & Docker
Cloud Foundry & Docker
CloudStack & Docker
CoreOS & Docker
Deis & Docker
Decker & Docker
Docker & Docker
Dokku & Docker
Eucalyptus & Docker
Flynn & Docker
Google Compute Platform & Docker
IBM Bluemix & Docker
Kubernetes & Docker
Mesos & Docker
Mesosphere & Docker
Microsoft Azure & Docker
OpenCamp & Docker
OpenShift & Docker
OpenStack & Docker
Panamax & Docker
Puppet & Docker
SaltStack & Docker
Shipyard & Docker
Stackato & Docker
Tsuru & Docker
VMware & Docker
As we can see, these eCosystems have Docker in common, but you might ask if and how all these implement the integration and enhance their own system with Docker and play with others and which of them might be the right solution for different use cases, i.e. to build (web-) apps, services or a whole cloud platform to provide for instance SaaS offerings or to help to achieve higher density in data centers and control the VM sprawl, etc..
Well, first I’m going to classify these eCosystems in the following categories:
Big Data
Cloud Platform
IaaS
Data Center Operating System
Docker Operating System
Docker Management
PaaS
Orchestration and Configuration Management Engines
which leads to the following table matrix:
One row, one column and one cell might capture your eye here and someone might argue that “Docker & Docker” doesn’t make any sense and why I’m classifying docker as IaaS, PaaS, Docker OS and as an Orchestration and Configuration Management Engine all together, well if we agree with the fact that we can build our IaaS and PaaS with docker and we can leverage the docker engine to orchestrate itself and run docker containers in docker containers, then I guess you’ll agree with this view.
The other interesting point is the PaaS column, which shows that most of these eCosystems are trying to address the PaaS challenge in different ways with docker. But as Ben Gloub, CEO of Docker Inc. states in [15] “a lot of people are questioning whether they really need a full PaaS to build a flexible app environment” and exactly here enterprises need to re-think thier strategies, whether they need to use Macro PaaSes such as Cloud Foundry or OpenShift, or should they build more efficient lightweight custom PaaS solutions with docker and the ecosystem arround it, we refer to such a custom made PaaS solution as OpenCamp, the Open Cloud Application Management Platform.
But what about the one cell, what is Mesos or Mesosphere and what is a “Data Center Operating System”? Well, that’s the new way of thinking, which I’m going to address in my next blog post.
But for now, if you ask me which of these systems are my favorites, I’d say Docker followed by Mesosphere, OpenStack, Kubernetes, Panamax and Deis!
Last but not least, I’d like to invite you to have a look on why “Docker Is Not Enough”.
[0] Docker related articles
[1] Introduction to Docker by Solomon Hykes, Docker Founder and CTO at Docker Inc.
https://www.youtube.com/watch?v=Q5POuMHxW-0
[2] What is Docker
https://www.docker.com/whatisdocker/
[3] WHAT IS DOCKER AND WHEN TO USE IT
http://www.centurylinklabs.com/what-is-docker-and-when-to-use-it/
[4] How Docker Was Born | Leanstack
http://blog.leanstack.io/how-docker-was-born
[5] How Docker Fits Into The Current DevOps Landscape
http://blog.leanstack.io/how-docker-fits-into-the-current-devops-landscape
[6] Crash Course: Next Generation Servers With Containers by Sébastien Han:
http://www.sebastien-han.fr/blog/2014/02/03/crash-course-next-generation-servers-with-containers/
[7] Docker drops LXC as default execution environment
http://www.infoq.com/news/2014/03/docker_0_9
[8] The key differentiators of Docker technology by Pethuru Raj
http://thoughtsoncloud.com/2014/09/docker-managing-excitement/
[9] Docker is the Heroku Killer
http://www.brightball.com/devops/docker-is-the-heroku-killer
[10] KVM and Docker LXC Benchmarking with OpenStack
http://bodenr.blogspot.de/2014/05/kvm-and-docker-lxc-benchmarking-with.html
[11] VMware buys into Docker containers
http://www.zdnet.com/vmware-buys-into-docker-containers-7000032947/
[12] 4 ways Docker fundamentally changes application development
http://www.infoworld.com/article/2607128/application-development/4-ways-docker-fundamentally-changes-application-development.html
[13] The Docker exploit and the security of containers
https://blog.xenproject.org/2014/06/23/the-docker-exploit-and-the-security-of-containers/
[14] OpenShift v3 Platform Combines Docker, Kubernetes, Atomic and More
https://www.openshift.com/blogs/openshift-v3-platform-combines-docker-kubernetes-atomic-and-more
[15] Simplifying and securing multicloud development
http://www.pwc.com/en_US/us/technology-forecast/2014/issue1/interviews/interview-ben-golub-docker.jhtml
[16] OpenStack & Docker
https://wiki.openstack.org/wiki/Docker
[17] Docker Jump Start by Andreaw Odewahn
https://github.com/odewahn/docker-jumpstart-source
From : https://www.cloudssky.com/en/blog/Docker-Is-Not-Enough/


Second Week of RC
Day 3: Achoo
February 27, 2019
I stayed home sick. Not much to report. Lots of sneezing and sleeping.


Released March 16, 2022
Second Inquisition is a sourcebook for Vampire: The Masquerade 5th Edition that covers the Second Inquisition, the tactics they employ to hunt Kindred, and the many facets of the organization from the FIRSTLIGHT initiative to the Society of Leopold.


--- date: 2010-03-13T00:00:00Z published: true title: A couple of interesting JQuery Links url: /2010/03/13/a-couple-of-interesting-jquery-links/ ---
Some neat stuff here - so many plugins:
45 Fresh Useful JavaScript and jQuery Techniques and Tools - Smashing Magazine
17 jQuery Plugins for Easy and Efficient Reordering and Filtering Page Elements | tripwire magazine
And some intro stuff I'm leaning towards going through shortly:
jQuery: The Write Less, Do More, JavaScript Library