Not long ago, response times in the seconds were considered appropriate. Browser refreshes were the norm in web applications. Systems would go down for hours of maintenance, or even be rebooted nightly, and this was ok because people only expected the systems to be up during business hours. Applications didn't have to scale because they didn't have big user bases. And the complexity requirements put on web applications meant that typical requests could easily be handled by a thread per request model.
Things are changing though. People expect web applications to react instantly. They expect them to be up all the time, while the applications are moving into the cloud, where failures are not exceptional, but rather are the norm, and so applications need to react to failure. Load on a web application can peak unpredictably, to be many orders of magnitude greater than normal, and so applications need to react to load and scale out. The complexity of business requirements means that in order to respond quickly to requests, things must be processed in parallel, reacting to events rather than waiting so as to utilise resources as efficiently as possible.
This application is an example of how to implement the tenants of the Reactive Manifesto.
It uses the latest in client side technologies to implement a reactive user interface. It uses a MongoDB database, using event driven IO via the ReactiveMongo database driver. And it maintains statelessness, ensuring that it can be easily scaled out to many nodes, for both fault tolerance and scalability.
In order to use this app, you'll need to install and run MongoDB on the default port. If you don't already have MongoDB installed, you can get it from here.
Once the application has been compiled and the server started, the application can be accessed at: http://localhost:9000. You can check in Run to see the server status.
Open the application by clicking the above link, and try adding some messages. The application is just a simple message board, you can post messages, the messages are paged.
Try opening the app in multiple browser tabs, or even different browsers. Notice that whenever any browser tab adds a message, the message instantly appears in every browser tab.
The HTML page you're seeing is implemented using Scala templates, so we'll start there. The main page is index.scala.html. It starts with a call to the main decorator template, main.scala.html. Inside it is first the modal dialog box for adding messages, then the text for the left hand side of the page, then the paging and rendering of messages.
You can see on many HTML elements there is a data-bind
attribute. These are
knockout.js binding attributes that allow binding data and
behaviour into the HTML page. You can also see the use of many
Bootstrap styles. Bootstrap allows you to create a very
good looking site within minutes.
Moving into main.scala.html, this is the template
that wraps all other templates (currently the only other one is the index). It is where the stylesheets and
Javascript assets are brought in. Notice the @routes.Assets.at()
and
@routes.WebJarAssets.at()
calls. These are reverse routes, they allow you to keep your routing
path configuration separate from the templates that consume the routing information. Also notice that we are
using RequireJS to handle JavaScript modularisation.
For more information on Scala templates, see here.
The client side code for this application is implemented using CoffeeScript. The main file for this code is app.coffee.
The first line of the file
is the RequireJS declaration, if you've used RequireJS
before, you may notice something different - some of the modules are prepended with webjars!
.
This tells RequireJS to use WebJars to locate these
modules. Rather than being managed by downloading them onto the filesystem, WebJars modules are managed by the
build system, you can see in the applications
Build.scala file dependencies declared on various
different WebJars. This has the advantage of upgrading being a simple configuration item, and also allows
WebJars, in combination with RequireJS, to automatically pull in transitive dependencies.
You'll also notice the routes.js
module, this is the
Play
JavaScript reverse router. Like the reverse router that we saw earlier, the JavaScript reverse router
allows you to decouple your routing path configuration from your JavaScript code. The JavaScript reverse router
is able to build dynamic URLs based on parameters that you pass in, and also knows the correct HTTP method for a given route.
The rest of the file is a knockout.js model, declaring a number of observable properties that are bound to in the templates we saw earlier, and declaring a number of behavioural methods that update the view and make ajax calls, using the JavaScript reverse router.
Most of the styles used by this application come from Bootstrap, and as we saw before, it was brought in via WebJars in main.scala.html.
We do need to define a very small amount of our own styling though, to do this we're using LESS, an extension to CSS that grants extra functionality so that you can write very concise, simple and easy to manage stylesheets. Play automatically compiles LESS stylesheets to CSS for you.
Our LESS style sheet can be found in main.less.
When Play receives a web request, it needs to know how to route that request to some code to handle the request. Play uses the routes file to declare this configuration, and then it compiles this into a statically typed router, and also compiles it into the reverse router and JavaScript router as we've already seen.
Each route declares a request method, a path, which may have some dynamic parts, and then an action to handle it. The action is a method on a controller, and the parameters to those methods are the dynamic parts of the path, as well as any query string parameters that you wish to pass. Since the routes file is compiled to Scala, an error, including type errors with parameters, will be found at compile time, you don't need to wait till runtime.
The first route in the routes file points to the index
method on the
MainController. This method simply
renders the index.scala.html template that we
saw earlier.
In the main controller you can also see the router
method, this is what generates the JavaScript
router. Each route that we want exposed in the JavaScript router is passed here.
You can read more about HTTP routing and actions in Play here.
This is an app that saves and retrieves messages, so we need to have some way to model these messages. This is done in the Message class.
You can see that a message as an id, the name given to it is _id
because this is what MongoDB
requires. The type of the id is a BSONObjectId
, again, this is a MongoDB data type that allows
generation of unique ids. And a message also has a message string.
In the Message
companion object, we have an implicit JSON Format
object. This will
be used whenever a message is passed to a method that requires a Format
type class. ReactiveMongo
requires this when saving or loading objects from the database, and the Play JSON library requires this when
serialising or deserialising objects to and from JSON.
The format object itself is created using the Json.format
macro. This allows 100% type safe at
compile time data binding of case classes to and from JSON, if Message
was to have a field of a
type that Play did not know how to handle, a compilation error would be thrown, you would not have to wait
until runtime to find that error.
You can read more information about Play's JSON handling here.
We are using ReactiveMongo to interface to MongoDB.
The code to save and load messages can be found in
MessageDao. The collection
method gets a reference to a MongoDB collection, if you haven't used MongoDB before, a collection is roughly
equivalent to a table in a relational database.
Notice that every method in the DAO returns Future
. A future is a value that may not yet be
available, but will be available sometime in the future. You cannot interact with it directly, there is no way
to get the value out of it now, in fact doing so would be very bad because it would require blocking if the
value wasn't yet available. Rather, you can interact by passing callbacks to methods such as map
and flatMap
. map
allows you to transform the value to another value, possibly of
another type, while flatMap
allows you to perform another asynchronous operation.
You can see in the save
method, after calling collection.save()
, we get back a future
of the status of the save call. But we want to return a Future[Message]
, so we map
the status future to a message, if the operation completed successfully. Since this code is non blocking, the
save
call will return almost immediately, before the database action has even started. But the
returned Future[Message]
allows the caller of the save
method to perform its own
operations once the future is redeemed.
You can read more about asynchronous programming in Play here.
As we saw before, all actions that we do on MongoDB are asynchronous, they return futures. Navigate to the
MessageController to see how we
use these asynchronous calls on MessageDao
.
As a simple example, take a look at the saveMessage
method. You can see that after calling
MessageDao.save
, we map its result to a 201 Created response. At this point we have a
Future[Result]
, we then wrap that in the Async
call to return it to Play, and Play
will handle that asynchronously, without blocking.
A more complex example is the getMessages
method, which makes multiple calls on the
MessageDao
, one to get the count of all messages, another to get a page of messages. To make
multiple asynchronous calls, we're using for comprehensions:
for {
count <- MessageDao.count
messages <- MessageDao.findAll(page, perPage)
} yield { ... }
Each line in the for block is equivalent to a call to flatMap
on the result of the line before.
This means each line is a callback that gets executed asynchronously - it looks like ordinary sequential code,
but actually is non blocking and asynchronous. The yield
block is equivalent to a
map
call on the eventual result.
Up to now we've seen how the app implements the loading and the saving of messages, from the frontend through to the backend. There's one major feature left to show, and that's how the browser reacts to new messages being published.
Notifying browsers about messages requires publishing events. A naive approach to event publishing would be to have an in memory register of event listeners. This works fine if you have one node, but in a scalable, fault tolerant and reactive world, this will not be the case.
There are many technologies that we could use to publish events that all nodes can see, including Akka and RabbitMQ. Since we're already using MongoDB, we're going to take a very simple option, MongoDB tailable cursors on top of capped collections.
A MongoDB capped collection is a collection with a maximum size, when that size is reached, the oldest documents written to the database are overwritten with any new documents that are inserted. Tailable cursors allow you to reactively receive documents from the collection as they are inserted into the collection.
The EventDao allows publishing of events and also produces a stream of events to subscribe to.
We load the collection in a bit of a different way to in the MessageDao
, we need to make sure that
the collection is configured to be a capped collection, and this requires some asynchronous calls to the
database that need to be made before the collection will be useable. For this reason, the collection is a
future, and so you can see each time we use it we use a for comprehension to get the actual collection.
Additionally, we don't want to do the check every time we use the collection, only when Play starts up. So we've implemented a Play plugin, this allows us to hook into the Play lifecycle. The plugin is registered in play.plugins.
The stream method creates an enumerator based on a tailable cursor of the collection. An enumerator is an asynchronous stream producer, enumerators get used in combination with iteratees, which are asynchronous stream consumers. This enumerator is also managed by the plugin, we ensure that there is only one tailable cursor opened for the whole app, and then we wrap this enumerator in a broadcast enumerator to allow many clients to consume from it.
You can read more about iteratees and enumerators here.
Our event stream is streamed to the browser using Server-Sent Events. The route for the stream can be found in the MainController. Our stream is fed into the event source enumeratee - an enumeratee is a transformer of asynchronous streams.
If you look in the Event model object, you can see that we've defined a comet message extractor for getting the data for the event, as well as an id extractor and a name extractor. The name extract in particular is important, it allows us to subscribe to events by name on the client side.
On the client side, at the bottom of
app.coffee, you can see where we are
creating the EventSource
stream (using the JavaScript reverse router to get the URL), and then
subscribing to message events. For each message event, we add the message (the data of the event) to the
messages on the screen, if we are on the first page.
Configuration for the application is defined in
application.conf. This is for example where the
mongodb.url
configuration is defined.
Configuration for the build system is defined in Build.scala. This is an sbt build file. Here all the dependencies of the application are declared, along with any build configuration.
No application is complete without comprehensive tests. We are using specs2 to test the app. You can run the tests by going to the Test tab, and clicking start. By default, activator will run the tests automatically for you each time you change file.
We've started by declaring some helpers in MongoDBTestUtils,
the primary thing being the withMongoDB
method, which sets up and tears down both Play and MongoDB
before and after the code block passed to it. It uses the Play test framework to help it, including the
running
method, and creates a FakeApplication
.
Navigate to MessageControllerSpec to see
an example set of specs. These invoke the methods on the message controller to test them. They also use a few
methods provided by the Play test framework, such as header
and contentAsString
,
which get headers and the body content out of possibly asynchronously produced results.
You can read more about testing your application here.
Now that we've got an overview of the whole codebase and how it works, let's start to add new functionality.
We want to add an author field to the messages, so we know who wrote them. Let's start with adding the author
field to the add message popup. Open
index.scala.html and add a new field below the
exsting form-group
div
:

Author
<input type="text" class="form-control" id="messageAuthorField" placeholder="Enter author"
data-bind="value: messageAuthorField"/>

You can see that we've bound the input element to the messageAuthorField
property in the model. Save the changes and now
let's add that to app.coffee,
just below the declaration for messageField
:
@messageAuthorField = ko.observable()
Save the file. Now if you refresh the app and click the Add message, you should see the new field, but it doesn't do anything yet. Let's modify the
saveMessage
method so that it adds the author field to the submitted JSON and then clear the messageAuthorField:
@ajax(routes.controllers.MessageController.saveMessage(), {
data: JSON.stringify({
message: @messageField()
author: @messageAuthorField()
})
contentType: "application/json"
}).done(() ->
$("#addMessageModal").modal("hide")
self.messageField(null)
self.messageAuthorField(null)
)
Make sure the indentation is correct and then save the file. Now to handle this newly submitted field on the server side, open the Message model, and add the authors field to it:
case class Message(_id: BSONObjectID, message: String, author: String)
Save your changes. Now update the MessageForm
in
MessageController to also accept
this field, and pass it to the Message
object when created:
case class MessageForm(message: String, author: String) {
def toMessage: Message = Message(BSONObjectID.generate, message, author)
}
Save your changes. Before testing this, you may want to prep the database, since any existing data in there won't have the new field. Open a MongoDB command line shell and drop the messages collection:
$ mongo messages
MongoDB shell version: 2.4.6
connecting to: messages
> db.messages.drop()
true
Now we should be able to save authors, the only thing left to do is to render them. Back in
index.scala.html, update the last

at the bottom of the file
to render the author field:

Save the file. Refresh the app and add a new message. Now we can see the authors, but they don't look pretty. Add some styling to main.less:
.messageAuthor {
font-style: italic;
color: gray;
float: right;
}
Save the file and refresh the app to see the styled author. And now you've finished adding your first feature to the app. The tests are broken though, let's fix them,
and add a new test. Modify the createMessage
method in the
MessageControllerSpec to also handle the author:
def createMessage(msg: String, author: String = "None") = {
Await.result(MessageDao.save(Message(BSONObjectID.generate, msg, author)), Duration.Inf)
}
And now modify the "save a message" spec to test saving authors:
"save a message" in withMongoDb { implicit app =>
status(MessageController.saveMessage(FakeRequest().withBody(
Json.obj("message" -> "Foo", "author" -> "Bar")
))) must_== CREATED
val messages = Await.result(MessageDao.findAll(0, 10), Duration.Inf)
messages must haveSize(1)
messages.head.message must_== "Foo"
messages.head.author must_== "Bar"
}
Save the file. Finally fix the EventsSpec to populate the author field:
val message = Message(BSONObjectID.generate, "Foo", "None")
Save the file and now the tests should all pass.
Now we want to allow people to like messages. We'll start off with implementing the backend. You may want to first drop the messages collection again, since we'll be modifying it. Add a likes integer to the Message model:
case class Message(_id: BSONObjectID, message: String, author: String, likes: Int)
Before going on, fix the code that creates Message
objects in
MessageControllerSpec and
EventsSpec.
Now we want to add a like
method to the
MessageDao:
def like(id: String): Future[Boolean] = {
collection.update(
Json.obj("_id" -> BSONObjectID(id)),
Json.obj("$inc" -> Json.obj("likes" -> 1))
).map {
case ok if ok.ok =>
ok.n == 1
case error => throw new RuntimeException(error.message)
}
}
You can see here that we're using a MongoDB atomic increment operation to update the likes property. As with
save
, update
returns a future, which we are mapping to be a Boolean
,
true
if the message existed (ok.n
returns the number of documents updated, so if it's
1, then the document must have existed), otherwise false
.
Now let's go to the
MessageController, and the first
thing we want to do is pass 0 into the Message
object created in MessageForm.toMessage
,
since a new message will start with 0 likes. Then we want to add a likeMessage
action:
def likeMessage(id: String) = Action {
Async {
MessageDao.like(id).map {
case true => NoContent
case false => NotFound
}
}
}
We're using our newly implemented MessageDao.like
method, which returns a
Future[Boolean]
, and we're mapping that to 201 No Content if successful, or 404 Not Found if not
found.
Now we need to define a route for our new action. In routes, somewhere above the last route (because it's a catch all route):
POST /message/:id/like controllers.MessageController.likeMessage(id)
And let's expose this route in our JavaScript router generated in MainController:
Routes.javascriptRouter("routes")(
routes.javascript.MainController.events,
routes.javascript.MessageController.likeMessage,
routes.javascript.MessageController.getMessages,
routes.javascript.MessageController.saveMessage
)
Finally, before we're done in the backend, we'll add a test in MessageControllerSpec:
"allow liking messages" in withMongoDb { implicit app =>
val message = createMessage("Foo")
status(MessageController.likeMessage(message._id.stringify)(FakeRequest())) must_== NO_CONTENT
Await.result(MessageDao.findAll(0, 10), Duration.Inf).head.likes must_== 1
}
Run the tests to make sure they pass.
Let's now implement support for likes on the front end. Let's start of with rendering them in messages list in index.scala.html:

We're using glyphicons from Bootstrap to render a thumbs up button. A little styling of our own main.less wouldn't go astray:
.likes {
float: left;
margin-right: 10px;
.icon {
cursor: pointer;
}
}
Now you can see that we bound clicking on the thumbs up icon to a likeMessage
callback, let's
implement that in app.coffee:
@likeMessage = (message) ->
self.ajax(routes.controllers.MessageController.likeMessage(message._id.$oid))
Note once again that we are using the JavaScript reverse router here. Now refresh your browser, and try liking a message. The likes won't appear immediately yet, but after a browser refresh, you should see them. Don't forget to drop your messages collection if you didn't already.
The final thing we want to implement is reactive likes - when a user likes a message, every browser that is
viewing the page should be updated with the new likes total for that message. On the backend, we'll utilise
our existing events mechanism to publish a like event when a message is liked. Update the like
method's success handler in the
MessageDao file:
case ok if ok.ok =>
EventDao.publish("like", id)
ok.n == 1
Let's extend the existing spec for events in EventsSpec by adding the following to the "publish a new event when a message is saved" test:
val likeEvent = EventDao.stream |>>> Iteratee.head
MessageDao.like(message._id.stringify)
Await.result(likeEvent, Duration.Inf) must beSome.like {
case event =>
event.name must_== "like"
Json.fromJson[String](event.data).asOpt must beSome(message._id.stringify)
}
In the front end, we want to start by making the likes property on each message observable. We'll write a small
utility function to do this, and add it to the MessagesModel
class in
app.coffee:
bindMessage: (message) ->
message.likes = ko.observable(message.likes)
Now when we load messages in the loadMessages
function, we want to apply this function to each
message:
loadMessages: (data, status, xhr) ->
data.forEach(@bindMessage)
@messages(data)
And we want to do the same for messages we've received via EventSource
:
message = JSON.parse(e.data)
model.bindMessage(message)
model.messages.unshift(message)
Now we can write a handler for like events sent to us by the server. Each time we recieve a like event, we want to iterate through the messages that we have, and if the like event is for that message, we'll increment its likes:
events.addEventListener("like", (e) ->
id = JSON.parse(e.data)
ko.utils.arrayForEach(model.messages(), (message) ->
if (message._id.$oid == id)
message.likes(message.likes() + 1)
)
)
Now check in your browser to see if it works. Congratulations, you've created a reactive app using Play, MongoDB and knockout.js!


2 Samuel 13:39
And the soul of king David longed to go forth unto Absalom: for he was comforted concerning Amnon, seeing he was dead.


Upload the manifest file to an SSL supported workspace and create a public link to use below.
Enter the public/shared link of the manifest file.


1. Data File Details
Halberstadt_lab_data_2.xlsx
Data file indeed publicly available and is in a machine and human readable format.
1. Data File Details
Halberstadt_lab_data_2.xlsx
Data file indeed publicly available and is in a machine and human readable format.


Parasite is a web applications framework with the purpose of hosting all kinds of web sites (called applications).
To this date, parasite includes the following applications:
All of the applications have the following UX structure:
To support this unified user experience, parasite has the notion of plugins - content plugins and navigation plugins.
The navigation plugins are responsible for the left half screen, and the content plugins are responsible for the right.
Every application can decide which plugins should be bundled with it.
If, for instance, there are multiple ways to navigate inside the application, the application can use multiple navigation plugins. The user can switch between the plugins using the plugins buttons.
In order for the plugins to communicate between them (e.g. - which item did the user select), and in order for the application to specify which items exist, there's the notion of navigation model.
The navigation model is simply a tree structure of navigation nodes, each such node holds an item.
The current navigation node is the node the user is currently viewing.
The role of the application is to build this tree (either in advance or in a lazy manner, e.g - only when the user navigates to a node will the application load the node's children).
In order to make parasite feel like an app and not like an old fasion website, it uses HTML5 style of state linked to the URL.
This means the state of the current app the user uses as well as where he is in the navigation tree and other information is encoded into the URL.
Parasite is responsible for making transitions between applications and navigation nodes seamlessly using the URL.


Use an externally-managed task definition, rather than one created by Jenkins. Allows you to use a task definition created in the AWS Console, command line, or other tools. Specifying an explicit task definition will override all other task definition options, and will prevent Jenkins from creating or modifying task definitions for this agent. (You should still specify reasonable CPU and memory sizes in Jenkins. The values will not be used by ECS, but will be used by Jenkins to estimate cluster capacity.)
You may specify either a full task definition ARN, a family name, or a family name and revision. If specifying only a family name, Jenkins will use the latest active task definition with that family name. If you enter the full ARN, Jenkins will always use the specified ARN, even if you create later revisions of the task definition. See the DescribeTaskDefinition API documentation for details.
For example, if the task definition you would like to use is in the "hello_world" family, you could enter "hello_world", "hello_world:8", or "arn:aws:ecs:us-east-1:123456789012:task-definition/hello_world:8" as the Task Definition Override.
Important: If your externally-managed task definition contains multiple container definitions (sidecars), the Jenkins agent container must be the first container defined in the task definition.


{% extends "layout.html" %} {% block page_title %} Question page {% endblock %} {% block content %} Back Survey pages Start survey Question pages About your service Building a new service Using PaaS for Additional prototype features Existing setup Further backend services Preferable features Storage requirements Other info Who should we contact Other pages Check your answers {% endblock %}


exports = module.exports = (aplSource) ->
require('./compiler').exec aplSource
This module's exports
is what require('apl')
will return in node.js
The module is callable, so that this would work:
#!/usr/bin/env node
require('apl')('⎕ ← "Hell, oh, world!"');
exports = module.exports = (aplSource) ->
require('./compiler').exec aplSource
JavaScript generated by the APL compiler needs createGlobalContext()
for
bootstrapping.
exports.createGlobalContext = ->
require('./helpers').inherit require './vocabulary'
A compile()
method is exposed so it can be called by
coffee-subscript and
others.
exports.compile = require('./compiler').compile


The ICO Journal – The latest Cryptocurrency news such as Bitcoin news, Coin News, Initial Coin Offering (ICO), Coin Desk, Coin Telegraph, Digital Currency, Ripple.
Could be all hogwash, but makes for interesting reading.
ryman11210-Aug-18 04:43 AM
I just get stoned and read the articles and laugh anymore.
Good times......one day I wont have to lmao
devpro10-Aug-18 06:23 AM
anyone want to buy some vrsc?
plz privte chat with me
Cryptoon10-Aug-18 06:33 AM
The upshot? Expect an approval – its a matter of when not if.
jl777c10-Aug-18 06:39 AM
definitely a reason to dump all crypto
some people really believe that the market prices in all things and if the market says something, it must be right
when to me it seems very clear the market is not very caring about the facts
jl777c10-Aug-18 06:49 AM
and for those who think KMD price has suffered in the bear market, take a look at projects like counterparty, peercoin, blackcoin. even zcash has taken a big loss from ATH.
Cryptoon10-Aug-18 06:50 AM
It's very clear the market is still very easily manipulated
1
in the grand scheme of things a 100 billion bitcoin market is very small
blackjok3r10-Aug-18 07:09 AM
The easiest way of manipulating a market is by controlling the media... hey ETF, wait no ETF etc...
Cryptoon10-Aug-18 07:34 AM
For an ETF, that fund is obligated to hold the underlying assets right?
So in contrast to futures which does not affect real btc trading volume, the ETF's should affect volume for BTC for example?(edited)
blackjok3r10-Aug-18 07:38 AM
Yes i think so, this is why the ICE deal was so good, as they have a way of securing the BTC in something I guess like an escrow, that is regulated. So that the "institutions" can "trust" it. Also the ICE deal is paid in BTC, rather than in USD like the futures we have already, which seem just a way to "bet" BTC will go either down or up, then manipulate the price to win the bet.
Cryptoon10-Aug-18 07:39 AM
Hmm, so if such an ETF get's approved
It's safe to say that depending on the size of the fund we will see buy pressure give or take the size of the fund?
Should be good for some fireworks, although I suspect some OTC trades will happen as well
Don't think many 100M usd btc buy orders happen :p
What if world pension funds invest 0.1% of their holdings in btc as a hedge
there are many OTC deals for BTC happening, in very large amounts, at a discount to the open market price. This allows to short it, buy it at 5% discount, dump part of it on the open market, push the price down 4%, make money on the shorts but not lose money on the cash buy.
$100 mil seems like it is not on the bigger side of these OTC deals, so what we see on the trading market is just a show where they paint the popular TA patterns to reinforce where they want the price to go
pick a low volume coin that you can be the main volume of. and see how easy it is to paint whatever TA pattern you want.
 Think it took them 11 months or so
That service LOL. Shit, pay me 25 an hour and il go through them for you
With an unverified account on binance, is there no way to trace tx back to you? Or would it be relatively easy
blackjok3r10-Aug-18 12:17 PM
I am using a basic unverified binance account for ages with no problems, but i am not really trying to hide anything, ie use same address's for ages etc.
snowdamn10-Aug-18 12:22 PM
what is withdraw limit for unverified Binance?
CHMEX10-Aug-18 12:23 PM
Non-veritified account: withdraw 2BTC per 24h (Start from 2017/8/3 12:00AM, Beijing Time)
snowdamn10-Aug-18 12:24 PM
thank you
i really would like to know how Bitfinex still gets away with it


Two methods of parameter passing are supported: the standard method and parameter passing using the Standard-C stdarg mechanism [6]. The second method supports an arbitrary number of arguments to be passed to C++ method. Figure 7 shows the two supported parameter-passing methods and examples. Figure 8 shows the implementation details of the required interfacing functions to support these two types of parameter passing.
To aid users in extracting arbitrary number of arguments from the
va_list
structure (through the use of Standard-C
va_start
, va_arg
and va_end
macros), a supporting
C++ class called objc_t
and its corresponding ``>>
''
overloaded output stream operator have been implemented and stored in
the in the supporting file ObjCsupport.h
. An example of the
usage is shown in Figure 7 in the user C++ implementation of
the sumN_x1
member method (in this case, to sum a list of three
real numbers).
Figure 9 shows the algorithm used to translate a C++ function
prototype to its Objective-C equivalent. The translation of the C++
function argument string to Objective-C equivalent is defined in the
writeobjc
action in the Classdesc's Objective-C base action definition
file writeobjc_base.h
.
To support the use of C++ only member-methods in the user model,
following member functions will not be translated to its
Objective-C equivalent: argument-list contains any C++ objects (such
as vector) or function-name that contain ``cpp_
'' prefix.


{% extends "common/base.html" %} {% load staticfiles %} {% block pagename %}contact{% endblock %} {% block head %} {% endblock %} {% block contact %}active{% endblock %} {% block content %}
Please contact the Greene Lab at<EMAIL_ADDRESS>for more information about participating in our research at UCSD or if you have any general questions.
UCSD Mailing Address:
Deanna Greene
University of California San Diego
9500 Gilman Dr.
La Jolla, CA 92093
Please contact Emily Bihun, Clinical Research Coordinator, at<EMAIL_ADDRESS>or<PHONE_NUMBER> for more information about participating in our research at WashU or if you have general research study questions.
Our Mailing Address:
Emily Bihun
Washington University School of Medicine
660 South Euclid Avenue
Campus Box 8134
St. Louis, MO 63110
This site was designed and coded by Andrew Van. View the source code here. Copyright (©) 2018 Andrew Van.


Apache C++ Standard Library User's Guide
Chapter 27: The Architecture of Iostreams
27.1 The Standard Iostreams
27.1.1 Type Safety
27.1.2 Extensibility to New Types
27.2 How the Standard Iostreams Work
27.2.1 The Iostream Layers
<IP_ADDRESS> The Formatting Layer
<IP_ADDRESS> The Transport Layer
<IP_ADDRESS> Locales
27.2.2 File and In-Memory I/O
27.3 How the Standard Iostreams Help Solve Problems
27.4 The Internal Structure of the Iostreams Layers
27.4.1 The Internal Structure of the Formatting Layer
<IP_ADDRESS> Iostreams Base Class ios_base
<IP_ADDRESS> The Iostreams Character Type-Dependent Base Class
<IP_ADDRESS> Character Traits
<IP_ADDRESS> The Input and Output Streams
<IP_ADDRESS> The File Streams
<IP_ADDRESS> The String Streams
27.4.2 The Transport Layer's Internal Structure
<IP_ADDRESS> The Stream Buffer
<IP_ADDRESS> The File Buffer
<IP_ADDRESS> The String Stream Buffer
27.4.3 Collaboration of Streams and Stream Buffers
27.4.4 Collaboration of Locales and Iostreams


Controllers
- Introduction
- Basic Controllers
- Controller Middleware
- Resource Controllers
- Dependency Injection & Controllers
- Route Caching
Introduction
Instead of defining all of your request handling logic as Closures in route files, you may wish to organize this behavior using Controller classes. Controllers can group related request handling logic into a single class. Controllers are stored in the app/Http/Controllers
directory.
Basic Controllers
Defining Controllers
Below is an example of a basic controller class. Note that the controller extends the base controller class included with Laravel. The base class provides a few convenience methods such as the middleware
method, which may be used to attach middleware to controller actions:
<?php
namespace App\Http\Controllers;
use App\User;
use App\Http\Controllers\Controller;
class UserController extends Controller
{
/**
* Show the profile for the given user.
*
* @param int $id
* @return View
*/
public function show($id)
{
return view('user.profile', ['user' => User::findOrFail($id)]);
}
}
You can define a route to this controller action like so:
Route::get('user/{id}', 'UserController@show');
Now, when a request matches the specified route URI, the show
method on the UserController
class will be executed. The route parameters will also be passed to the method.
{tip} Controllers are not required to extend a base class. However, you will not have access to convenience features such as the
middleware
,validate
, anddispatch
methods.
Controllers & Namespaces
It is very important to note that we did not need to specify the full controller namespace when defining the controller route. Since the RouteServiceProvider
loads your route files within a route group that contains the namespace, we only specified the portion of the class name that comes after the App\Http\Controllers
portion of the namespace.
If you choose to nest your controllers deeper into the App\Http\Controllers
directory, use the specific class name relative to the App\Http\Controllers
root namespace. So, if your full controller class is App\Http\Controllers\Photos\AdminController
, you should register routes to the controller like so:
Route::get('foo', 'Photos\AdminController@method');
Single Action Controllers
If you would like to define a controller that only handles a single action, you may place a single __invoke
method on the controller:
<?php
namespace App\Http\Controllers;
use App\User;
use App\Http\Controllers\Controller;
class ShowProfile extends Controller
{
/**
* Show the profile for the given user.
*
* @param int $id
* @return View
*/
public function __invoke($id)
{
return view('user.profile', ['user' => User::findOrFail($id)]);
}
}
When registering routes for single action controllers, you do not need to specify a method:
Route::get('user/{id}', 'ShowProfile');
You may generate an invokable controller by using the --invokable
option of the make:controller
Artisan command:
php artisan make:controller ShowProfile --invokable
Controller Middleware
Middleware may be assigned to the controller's routes in your route files:
Route::get('profile', 'UserController@show')->middleware('auth');
However, it is more convenient to specify middleware within your controller's constructor. Using the middleware
method from your controller's constructor, you may easily assign middleware to the controller's action. You may even restrict the middleware to only certain methods on the controller class:
class UserController extends Controller
{
/**
* Instantiate a new controller instance.
*
* @return void
*/
public function __construct()
{
$this->middleware('auth');
$this->middleware('log')->only('index');
$this->middleware('subscribed')->except('store');
}
}
Controllers also allow you to register middleware using a Closure. This provides a convenient way to define a middleware for a single controller without defining an entire middleware class:
$this->middleware(function ($request, $next) {
// ...
return $next($request);
});
{tip} You may assign middleware to a subset of controller actions; however, it may indicate your controller is growing too large. Instead, consider breaking your controller into multiple, smaller controllers.
Resource Controllers
Laravel resource routing assigns the typical "CRUD" routes to a controller with a single line of code. For example, you may wish to create a controller that handles all HTTP requests for "photos" stored by your application. Using the make:controller
Artisan command, we can quickly create such a controller:
php artisan make:controller PhotoController --resource
This command will generate a controller at app/Http/Controllers/PhotoController.php
. The controller will contain a method for each of the available resource operations.
Next, you may register a resourceful route to the controller:
Route::resource('photos', 'PhotoController');
This single route declaration creates multiple routes to handle a variety of actions on the resource. The generated controller will already have methods stubbed for each of these actions, including notes informing you of the HTTP verbs and URIs they handle.
You may register many resource controllers at once by passing an array to the resources
method:
Route::resources([
'photos' => 'PhotoController',
'posts' => 'PostController'
]);
Actions Handled By Resource Controller
| Verb | URI | Action | Route Name |
|---|---|---|---|
| GET | /photos |
index | photos.index |
| GET | /photos/create |
create | photos.create |
| POST | /photos |
store | photos.store |
| GET | /photos/{photo} |
show | photos.show |
| GET | /photos/{photo}/edit |
edit | photos.edit |
| PUT/PATCH | /photos/{photo} |
update | photos.update |
| DELETE | /photos/{photo} |
destroy | photos.destroy |
Specifying The Resource Model
If you are using route model binding and would like the resource controller's methods to type-hint a model instance, you may use the --model
option when generating the controller:
php artisan make:controller PhotoController --resource --model=Photo
Spoofing Form Methods
Since HTML forms can't make PUT
, PATCH
, or DELETE
requests, you will need to add a hidden _method
field to spoof these HTTP verbs. The @method
Blade directive can create this field for you:
<form action="/foo/bar" method="POST">
@method('PUT')
</form>
Partial Resource Routes
When declaring a resource route, you may specify a subset of actions the controller should handle instead of the full set of default actions:
Route::resource('photos', 'PhotoController')->only([
'index', 'show'
]);
Route::resource('photos', 'PhotoController')->except([
'create', 'store', 'update', 'destroy'
]);
API Resource Routes
When declaring resource routes that will be consumed by APIs, you will commonly want to exclude routes that present HTML templates such as create
and edit
. For convenience, you may use the apiResource
method to automatically exclude these two routes:
Route::apiResource('photos', 'PhotoController');
You may register many API resource controllers at once by passing an array to the apiResources
method:
Route::apiResources([
'photos' => 'PhotoController',
'posts' => 'PostController'
]);
To quickly generate an API resource controller that does not include the create
or edit
methods, use the --api
switch when executing the make:controller
command:
php artisan make:controller API/PhotoController --api
Naming Resource Routes
By default, all resource controller actions have a route name; however, you can override these names by passing a names
array with your options:
Route::resource('photos', 'PhotoController')->names([
'create' => 'photos.build'
]);
Naming Resource Route Parameters
By default, Route::resource
will create the route parameters for your resource routes based on the "singularized" version of the resource name. You can easily override this on a per resource basis by using the parameters
method. The array passed into the parameters
method should be an associative array of resource names and parameter names:
Route::resource('users', 'AdminUserController')->parameters([
'users' => 'admin_user'
]);
The example above generates the following URIs for the resource's show
route:
/users/{admin_user}
Localizing Resource URIs
By default, Route::resource
will create resource URIs using English verbs. If you need to localize the create
and edit
action verbs, you may use the Route::resourceVerbs
method. This may be done in the boot
method of your AppServiceProvider
:
use Illuminate\Support\Facades\Route;
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
Route::resourceVerbs([
'create' => 'crear',
'edit' => 'editar',
]);
}
Once the verbs have been customized, a resource route registration such as Route::resource('fotos', 'PhotoController')
will produce the following URIs:
/fotos/crear
/fotos/{foto}/editar
Supplementing Resource Controllers
If you need to add additional routes to a resource controller beyond the default set of resource routes, you should define those routes before your call to Route::resource
; otherwise, the routes defined by the resource
method may unintentionally take precedence over your supplemental routes:
Route::get('photos/popular', 'PhotoController@method');
Route::resource('photos', 'PhotoController');
{tip} Remember to keep your controllers focused. If you find yourself routinely needing methods outside of the typical set of resource actions, consider splitting your controller into two, smaller controllers.
Dependency Injection & Controllers
Constructor Injection
The Laravel service container is used to resolve all Laravel controllers. As a result, you are able to type-hint any dependencies your controller may need in its constructor. The declared dependencies will automatically be resolved and injected into the controller instance:
<?php
namespace App\Http\Controllers;
use App\Repositories\UserRepository;
class UserController extends Controller
{
/**
* The user repository instance.
*/
protected $users;
/**
* Create a new controller instance.
*
* @param UserRepository $users
* @return void
*/
public function __construct(UserRepository $users)
{
$this->users = $users;
}
}
You may also type-hint any Laravel contract. If the container can resolve it, you can type-hint it. Depending on your application, injecting your dependencies into your controller may provide better testability.
Method Injection
In addition to constructor injection, you may also type-hint dependencies on your controller's methods. A common use-case for method injection is injecting the Illuminate\Http\Request
instance into your controller methods:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class UserController extends Controller
{
/**
* Store a new user.
*
* @param Request $request
* @return Response
*/
public function store(Request $request)
{
$name = $request->name;
//
}
}
If your controller method is also expecting input from a route parameter, list your route arguments after your other dependencies. For example, if your route is defined like so:
Route::put('user/{id}', 'UserController@update');
You may still type-hint the Illuminate\Http\Request
and access your id
parameter by defining your controller method as follows:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class UserController extends Controller
{
/**
* Update the given user.
*
* @param Request $request
* @param string $id
* @return Response
*/
public function update(Request $request, $id)
{
//
}
}
Route Caching
{note} Closure based routes cannot be cached. To use route caching, you must convert any Closure routes to controller classes.
If your application is exclusively using controller based routes, you should take advantage of Laravel's route cache. Using the route cache will drastically decrease the amount of time it takes to register all of your application's routes. In some cases, your route registration may even be up to 100x faster. To generate a route cache, just execute the route:cache
Artisan command:
php artisan route:cache
After running this command, your cached routes file will be loaded on every request. Remember, if you add any new routes you will need to generate a fresh route cache. Because of this, you should only run the route:cache
command during your project's deployment.
You may use the route:clear
command to clear the route cache:
php artisan route:clear


--- layout: template menu : tutorial title : Recipes tutorial ---
In this tutorial, you will learn how to use a custom record reader with Easy Batch. The goal is to process recipes defined in the following recipes.csv
file:
R,Easy chocolate cake
I,chocolate,500g
I,sugar,100g
I,cocoa powder,50g
END
R,Ice cream
I,ice,100g
I,cream,50g
END
Each recipe is defined on multiple physical records:
We would like to map each set of physical records to the following domain model classes:
public class Ingredient {
private String name;
private int quantity;
//Getters and setters omitted
}
public class Recipe {
private String name;
private List<Ingredient> ingredients;
//Getters and setters omitted
}
To keep the tutorial simple, processing logic should simply write recipes data to the console.
So let's get started!
First, we will define a logical
recipe record that represent multiple physical records in the flat file:
public class RecipeRecord implements Record<Recipe> {
private int number;
private Recipe recipe;
public RecipeRecord(int number, Recipe recipe) {
this.number = number;
this.recipe = recipe;
}
@Override
public int getNumber() {
return number;
}
@Override
public Recipe getRawContent() {
return recipe;
}
}
This logical
record holds the record number and an instance of the recipe as raw content.
Next, we will implement a custom RecordReader
that will read multiple physical records to produce a logical RecipeRecord
, so here is the implementation:
public class RecipeRecordReader implements RecordReader {
public static final String SEPARATOR = ",";
/**
* Data source file.
*/
private File file;
/**
* Scanner to read the input file.
*/
private Scanner scanner;
/**
* The current read record number.
*/
private int currentRecordNumber;
public RecipeRecordReader(File file) {
this.file = file;
}
@Override
public void open() throws Exception {
scanner = new Scanner(file);
}
@Override
public boolean hasNextRecord() {
return scanner.hasNextLine();
}
@Override
public Record readNextRecord() throws Exception {
currentRecordNumber++;
Recipe recipe = new Recipe();
while (scanner.hasNext()) {
String line = scanner.nextLine();
if (line.startsWith("END")) {
break;
} else if (line.startsWith("R")) { //recipe line
String[] strings = line.split(SEPARATOR);
recipe.setName(strings[1]);
} else if (line.startsWith("I")) { //ingredient line
String[] strings = line.split(SEPARATOR);
Ingredient ingredient = new Ingredient();
ingredient.setName(strings[1]);
ingredient.setQuantity(Integer.valueOf(strings[2]));
recipe.getIngredients().add(ingredient);
}
}
return new RecipeRecord(currentRecordNumber, recipe);
}
@Override
public Integer getTotalRecords() {
// not implemented in this tutorial.
return null;
}
@Override
public String getDataSourceName() {
return file.getAbsolutePath();
}
@Override
public void close() throws Exception {
scanner.close();
}
}
The implementation is pretty straightforward. All the trick is in the readNextRecord
method: this is where we iterate on physical records until finding a "END" record to create a recipe instance.
In this use case, the record reader not only reads data but also maps data to domain objects.
Mapping data to domain objects is the role of the RecordMapper
component.
We could have implemented the record reader to only read data and create a RecipeRecord
with a String containing physical records to be mapped by a RecipeRecordMapper
,
but in this case, we will iterate twice on physical records : a first time when reading data and a second time when mapping data. That's why we have implemented the recipe reader to read and map data at the same time.
Nevertheless, to keep things coherent, we will create a RecipeRecordMapper
that will simply return the raw content of a RecipeRecord
which is the Recipe
instance:
public class RecipeMapper implements RecordMapper<Recipe> {
@Override
public Recipe mapRecord(Record record) throws Exception {
RecipeRecord recipeRecord = (RecipeRecord) record;
return recipeRecord.getRawContent();
}
}
Next, we will implement a RecipeProcessor
that simply writes recipes data to the console:
public class RecipeProcessor extends AbstractRecordProcessor<Recipe> {
@Override
public void processRecord(Recipe recipe) throws Exception {
System.out.println("recipe = " + recipe);
}
}
Finally, let's configure an Easy Batch engine to:
recipes.csv
file using our custom RecipeRecordReader
RecipeRecord
recordRecipeProcessor
The following listing provides this configuration:
public class Launcher {
public static void main(String[] args) throws Exception {
//initialize input file recipes.csv
File recipes = new File(args[0]);
// Build an easy batch engine
EasyBatchEngine easyBatchEngine = new EasyBatchEngineBuilder()
.registerRecordReader(new RecipeRecordReader(recipes))
.registerRecordMapper(new RecipeMapper())
.registerRecordProcessor(new RecipeProcessor())
.build();
// Run easy batch engine and get execution report
EasyBatchReport easyBatchReport = easyBatchEngine.call();
// Print Easy Batch report
System.out.println(easyBatchReport);
}
}
That's all, we can now run the batch and see the results.
The complete source code of this tutorial is available here.
To run the tutorial with maven, launch the following command in the easybatch-tutorials
directory :
mvn exec:java -PrunRecipesTutorial
At the end of execution, you should see the following output in the console:
INFO: Initializing easy batch engine
INFO: Data source: /data/in/recipes.csv
INFO: Strict mode: false
INFO: Total records = N/A
INFO: easy batch engine is running...
recipe = Recipe{name='Easy chocolate cake', ingredients=[Ingredient{name='chocolate', quantity=500}, Ingredient{name='sugar', quantity=100}, Ingredient{name='cocoa powder', quantity=50}]}
recipe = Recipe{name='Ice cream', ingredients=[Ingredient{name='ice', quantity=100}, Ingredient{name='cream', quantity=50}]}
INFO: Shutting down easy batch engine
Easy Batch Report:
Start time = 2014-02-16 10:59:08
End time = 2014-02-16 10:59:08
Batch duration = 0s
Data source = /data/in/recipes.csv
Total records = 2
Filtered records = 0 (0%)
Ignored records = 0 (0%
Rejected records = 0 (0%)
Error records = 0 (0%)
Success records = 2 (100%)
Average record processing time = 0.0s
In this tutorial, we have seen how to provide a custom record reading strategy with Easy Batch.


Home
LiveBot
Members:
Infinite
BOT
User
#1234
There are a few common issues that can occur in the loading screen. If you're having an issue, follow these steps to resolve any issues. If you're still having problems after that, join the support server.
Try disabling your Windows Defender firewall temporarily, then restarting LiveBot, to see if that fixes your issue. You can also then choose to enable LiveBot through your firewall if that solves the problem.
Your bot will need to be in at least 1 server for LiveBot to get past the loading screen. Try making a temporary testing server, and invite the bot to it, then restart LiveBot.
LiveBot requires both gateway intents to be enabled.
If the loading screen is stuck saying "Logging into the bot", then you may need to clear the local storage cache. To do that easily, click the button below, then restart LiveBot.
Home
Members:
Infinite
BOT
User
#1234


The fact is theory alone just won’t do in getting you closer towards project and professional success. The following real-world stories featuring brands traversing the thickets of organic content marketing are an integral part of your learning process towards becoming an industry practitioner.
Make sure to read and understand each brand’s journey through thick and thin as well as visit their homepage & blogs, tracking back their post history and researching them via SimiliarWeb in order to explore and understand first hand exactly how they managed to attain their current market positioning.
ThriveTheme creates Wordpress themes and plugins for rapid conversion rate optimization (CRO). Their case study presents how their initial segmentation of their audience based on first-base engagement prior to a form registration both creates value for the client via personalization, as well as lets them feel heard right from step one. After registration ThriveTheme show the business value of a welcome email as both the first contact with the recipient- dictating whether future emails will be opened, as well as the most opened and clicked through types of email. ThriveTheme also use a customized tag for recipients who’re currently taking part of a targeted automation in order to filter them out of general email campaigns so they won’t hurt their position with their recipients’ current phase of the customer journey.
Read the full case study on ActiveCampaign
Tracking back to the increased conversion rates of email marketing vs. social media, Digital Impulse share how they shifted the focus of their social media marketing from getting sales to getting email registrations allowing them to leverage the medium of email marketing for maximum conversions and ROI. Using this method they managed to effectively segment their audience using SMM demographics, retarget their audience in a cross-platform fashion and more.


Information gathering in a penetratino test is the most important phase. Knowing your target before attacking it is a proven recipe for success. Even mundane forum posts can provide you with useful information.
Find email addresses?- Do any of the emails have passwords exposed from breaches?
Find potential password keywords to use against a target?
Find interests for targeted phishing?
Find developer technologies a company is using?
Find IPs and certificates with targets?
And so. much. more!
1. Whois Information
2. Subdomains
3. Dir info
4. S3 Buckets
5. social accounts
6. API Endpoints
7. emails
8. Vhosts
9. Backend IP address
10. Open Ports / Services running
11. Service version info (if applicable)
12. server banners
13. directory listings
14. presence security headers
15. document metadata


Kun ZhanSchool of Information Science and Engineering, Lanzhou University kzhanlzu.edu.cn, ice.echogmail.com |
He received B.S. and Ph.D. degrees from Lanzhou University, in 2005 and 2010, respectively. He was a visiting student with Dalhousie University from 2009 to 2010 and was a visiting scholar with University of Technology Sydney from 2017 to 2018. He is currently with Lanzhou University. Here is his CV.
His general research interests are in machine learning, neural networks, and optimization.
Selected Publications:
Multiview consensus graph clustering |
Graph structure fusion for multiview clustering |
Adaptive structure discovery for multimedia analysis using multiple features |
Graph learning for multiview clustering |
Adaptive structure concept factorization for multiview clustering |
Computational mechanisms of pulse-coupled neural networks: A comprehensive review |
|
Feature-linking model for image enhancement |
|
New spiking cortical model for invariant texture retrieval and image processing |
| [more] |


St. agur blue cheese who moved my cheese emmental. St. agur blue cheese boursin cheeseburger lancashire manchego boursin when the cheese comes out everybody's happy smelly cheese. Cheddar cheese slices bavarian bergkase fromage frais chalk and cheese stilton bocconcini goat. Taleggio croque monsieur fromage frais cheese and wine.
Mascarpone cheesy grin smelly cheese. Edam emmental queso cheese and biscuits stilton port-salut cheese slices brie. Cheese triangles camembert de normandie cheeseburger paneer ricotta fromage frais cheesy feet queso. Lancashire camembert de normandie.
Cheesy feet when the cheese comes out everybody's happy monterey jack. Melted cheese airedale camembert de normandie cheese and wine cheese slices feta feta jarlsberg. Danish fontina blue castello cheesy grin everyone loves pepper jack goat brie caerphilly. Cow fromage taleggio lancashire.
Fromage frais pecorino mascarpone. Danish fontina parmesan st. agur blue cheese st. agur blue cheese caerphilly cottage cheese mozzarella fondue. Goat cheese and biscuits cheeseburger taleggio caerphilly squirty cheese cheese and wine cottage cheese. Pepper jack fondue cheese and biscuits.
Taleggio melted cheese who moved my cheese. Mozzarella mozzarella who moved my cheese lancashire cow halloumi lancashire mascarpone. Cauliflower cheese danish fontina pecorino parmesan cheddar when the cheese comes out everybody's happy cheese and wine gouda. Cauliflower cheese mascarpone cauliflower cheese dolcelatte macaroni cheese croque monsieur cheese on toast stilton. Port-salut lancashire pepper jack.
Halloumi ricotta roquefort. Fondue port-salut cheese on toast cheese triangles cheese and biscuits babybel feta goat. Cheese strings emmental cheeseburger cheeseburger cheese slices cheese on toast bavarian bergkase cream cheese. Cut the cheese the big cheese caerphilly roquefort cheese and wine lancashire stinking bishop emmental. Mascarpone cow macaroni cheese.


To use BPAD all you need is a computer and internet access. Choose whichever scenes you'd like and send a link to a candidate's email. Candidates will watch the chosen scenes then use their webcam to record a response. Or you can conduct the process in-house. Click the button below to learn more.
How it worksBPAD's virtual interactive scenarios allow employers to experience firsthand how candidates will behave in situations specific to the job. This method is much more telling than the classic question and answer interview process. Click the button to discover the research and psychology behind BPAD.
About BPADBPAD uses a clean and intuitive interface at every point of the process, for both the hiring managers and candidates. Basic instructions are available to view anytime. Feel free to call or email us for a quick personal response.
Contact UsThe benefits of BPAD:


--- layout: post title: Arrr! date: 2006-07-07 00:00:00 categories: amusing personal ---
Went to see Pirates of the Caribbean 2 last night. OK - a bit more Carrrrry On than the first one but good to see Geoffrey Rush making a return for the third instalment. Arrr!


fun periodic(): Unit
Overrides Command.periodic
Runs the Command.periodic function of the correct Command.


Link table between the assessment and the questions data and describe high-level information of questions in an assessment.
| Name | Description |
|---|---|
| assessment_id | The id that uniquely identifies an assessment |
| assessment_question_id | The id that uniquely identifies a question in an assessment |
| assessment_question_internal_id | No column description available |
| assessment_question_cuepoint | The number of milliseconds into a lecture video that the in-video question is placed. For quizzes that are not in-video quizzes, it is 0. |
| assessment_question_order | Order in which the questions are asked in the assessment. |
| assessment_question_weight | No column description available |
CREATE TABLE assessment_assessments_questions ( assessment_id VARCHAR(50) ,assessment_question_id VARCHAR(50) ,assessment_question_internal_id VARCHAR(50) ,assessment_question_cuepoint INT4 ,assessment_question_order INT4 ,assessment_question_weight INT4 ,PRIMARY KEY (assessment_id, assessment_question_id, assessment_question_internal_id) ,FOREIGN KEY (assessment_id) REFERENCES assessments(assessment_id) ,FOREIGN KEY (assessment_question_id) REFERENCES assessment_questions(assessment_question_id) );


This is a beta release for charts, which are dynamic and populated by the data currently in the CHPL. We will be working on iterating this feature over the coming months. Please use the Health IT Feedback Form for questions or comments.
The charts below describe the number of unique products that have been certified to each of the ONC certification criteria. A unique product represents a group of CHPL listings that refer to a single product from the same developer, each listing in a group often differing by version number.
Since the start of the ONC Health IT Certification Program, there have been three certification editions: 2011, 2014, and 2015. The charts below describe the transition between each edition by certified health IT developers. The regulations for each edition can be found here.
The 2011 edition has been retired and has no "Active" listings.
The safety-enhanced design (SED) criteria requires health IT developers to apply and test user centered design standards to their certified health IT. Developers follow NISTIR 7742 and submit results to ONC. SED testing requires participants who work in the health care field for which the product is intended to be used. The charts below describe the characteristics of the SED test participants for ONC certified health IT products.


Each Client-Central application has maintainable access rights. They are read, write (add), modify (update), and delete privileges granted to users enabling them to perform certain functions within the applications. This page allows you to specify access rights for each application selected on the Add Applications page for this new user.
Note: Every institution has one designated primary security administrator. Maximum privileges applicable to the institution are defined on this user's security record. Other administrators and users can be given the same or lesser privileges. When adding or maintaining a user record, you are not able to give more access than you have. Please refer to the User Administration User Manual for further details.
Click the following links for more information:
Key Information
Auto-filled with client and cardholder identification values.
| First Name | First name of the user whose record is being created. |
| Last Name | Last name of the user whose record is being created. | Institution ID | Four-character alphanumeric logical network assigned by EFT for the selected institution. |
Access Rights
Allows selection of access rights, by application, relating to the new user.
| Access Rights |
You can grant and revoke read, add, update, and delete access for the identified pages within each application. Note: Only the set of applications that you selected on the Add Applications page display on this page. |
| Select All | This button automatically checks all allowable access rights for the applications listed. |
| Clear | This button automatically unchecks all allowable access rights. |
| Reset | This button resets access rights to the original values existing at the time the page was accessed. |
| Read Only | This button automatically checks read (only) access rights for the identified pages within each application. |
| Back |
The Back button temporarily stores the access right information specified on the new user's security record and takes you to the previous page. Clicking Back from the Add Access Rights page takes you to the Add Applications page. |
| Continue |
The Continue button temporarily stores the access right information specified on the new user's security record and takes you to the next page. Clicking Continue from the Add Access Rights page takes you to the Add Special Roles page or to the Add Availability page. The Add Special Roles page displays only if you have at least one special role defined on your security record. |
| Cancel |
The Cancel button discontinues the add user process and returns you to the Choose User page. Clicking Cancel from the Add Access Rights page displays the following confirmation message: |


Told off for sitting on boyfriend’s knees and clothes, Aussie woman sounds off airlines in Twitter rant
by BY CLAIRE ROBERTSKUALA LUMPUR, Nov 7 — An Australian woman has taken to social media to complain about alleged mistreatment by an airlines company.
In the incident, Serah Nathan, 33 said she was sitting on her boyfriend’s knees and talking to him at Sydney Airport when she was approached by a Jetstar employee.
She said they were talking about their plans for the week when approached.
Nathan alleges the employee told her to “sit on a separate seat because there are children watching”.
“I begun questioning my partner about what airport law we broke by sharing a seat.” Nathan said in her complaint to Jetstar that she posted on Twitter.
The Jetstar employee returned with a Team Leader who said that she doubted whether Nathan would be allowed to fly given her choice of attire.
Nathan was waiting for a Tiger Air flight. Dressed in tracksuit pants, and a singlet tucked into her bra, Nathan arrived in Melbourne having flown with Jetstar’s budget airline rival Tiger Air.
She subsequently complained to Jetstar’s online customer service portal.
Here, she claimed that the customer service agent handled her complaint inappropriately by saying that she was “very beautiful” and that her boyfriend was lucky to have her.
The agent also said that it was inappropriate for her to sit on her boyfriend’s knees as there were other seats available and believed that the staff was only protecting other passengers.
“I can understand that you were not engaging in a sexual activity, but then again I believe that this kind of body language must be done in a private place,’ the response read.
Nathan believes her heritage of being half Sri Lankan played a role in her treatment while Jetstar denies any discrimination based upon her race.

Jetstar has apologised to Nathan for the initial handling of her case.
“We apologise to Serah for the manner in which her query was handled by our online customer service representative which fell well short of the standards we expect.”
When speaking to news.com.au, a Jetstar spokesperson said there was an investigation continuing into Serah Nathan’s case.
“We are speaking to our airport team to better understand what happened,” a Jetstar spokesperson said.


The Mathematical Marine Ecology Lab uses mathematical, statistical and computational tools to investigate human impacts on our oceans - and to find solutions. By developing models of marine ecosystems based on differential equations and cutting-edge statistical approaches using high-performance computing, we aim to better understand key system drivers, conserve biodiversity, and ensure productive fisheries under climate change.
The Principal Investigator, Professor Anthony J. Richardson, is a 2018 highly cited researcher in Ecology. He has a joint research position between the School of Mathematics and Physics at the University of Queensland and CSIRO Oceans and Atmosphere, Australia’s national science provider.
This website introduces our lab, its members, and summarises our activities. If you have a background in mathematics/statistics and want to apply your skills to real-world problems, of if you have a background in ecology and are interested in developing your quantitative skills, then this could be the lab for you. Feel free to contact us - we are always looking for motivated students to join our lab!


The Beetroot is a dine-in and take-out restaurant celebrating fresh, homemade vegan foods and baked goods. The goal for this project was to create an identity for a smaller brand and focus on the fun, community-driven, and tight knit elements but execute it on a bigger and more professional scale to really set the brand apart and give room for future growth. The patterned image works as the centrepiece for the rest of the branding elements and is featured on the packaging and business cards, and even as a very subtle overlay on the menu and business card fronts. I played with various layouts and alternate iconography for the logo as options depending on the usage. The logo has no set colour and can be used with any colour from the brand's palette which is demonstrated below.


This is h1
This is h2
This is h3
This is h4
This is h5
This is h6
This is italics
This is bold
This is Apple's site in the same window!
This is google in a new window
Mail to my email!
- This is the first item
- This is the second item
- This is the first ordered item
- This is the second ordered item


WEEKEND AT BERNIE'S 2 A film review by James Berardinelli Copyright 1993 James Berardinelli
Rating: 4.2 out of 10 (D, *1/2 out of ****)
Date Released: 7/9/93 Running Length: 1:29 Rated: PG (Language, brief nudity, dead body abuse)
Starring: Andrew McCarthy, Jonathan Silverman, Terry Kiser, Barry Bostwick Director: Robert Klane Producer: Victor Drai and Joseph Perez Screenplay: Robert Klane Music: Peter Wolf Released by TriStar
Dead man seen dancing in a Congo line, picking up date for the rest of the night, and fighting with her overmuscled boyfriend. Film at eleven.
 It's a perfect VCR film--little or no attention is required to the plot, you can walk out of the room and come back in without missing anything, and the reduction of the picture to television size does nothing to hurt the film. It's not intuitive to expect a sequel to this brainless movie, but the original WEEKEND did surprisingly well at the box-office. Add to that the results from a big video market and a second installment became in inevitability.
Part two, helmed by Robert Klane, the man behind the previous effort, starts off basically where part one ends. Bernie (Terry Kiser), murdered in the original film, is now in the morgue.  This starts them on a treasure hunt for the missing two million dollars that Bernie embezzled from the company. Also along for the ride is Hummel (Barry Bostwick), the company's sneering head-of-security, who needs to find the money to save his job. Then there's a third group, working for some unnamed criminals, and using voodoo to animate Bernie's dead corpse so that it will lead them to the cash.
Like HOME ALONE 2, WEEKEND AT BERNIE'S 2 is pretty much a re-hash of the first movie. You get just about what you expect--two morons dragging around a dead body (that they use deodorant to "freshen up") that everyone mistakes as being alive. There's a girl who spends a night on the beach with Bernie (no sex--not even this movie is that off-color) and claims it was the most enjoyable time she's had in a while. Of course, the corpse also gets viciously abused in every manner possible, without ever showing a scratch. In addition to repeats of what happened in WEEKEND 1, the body gets stuffed in a suitcase, jammed into a refrigerator, and shot through the head with an arrow.
In this movie, the body can move, thanks to a voodoo ceremony involving a pigeon (replacing a chicken that ran away--smart move on the chicken's part). We're treated to numerous scenes in which a herky-jerky Bernie dances to whatever tune is playing nearby. However, when the music stops, the body collapses like a marionette with its strings cut.
As was true in WEEKEND 1, the best performance is turned in by Terry Kiser as the corpse. That certainly isn't an endorsement of the abilities of the rest of the cast, but it's a true statement. Kiser's sense for physical comedy is good, and he manages to infuse this otherwise worthless movie with enough energy to keep it out of the bottom rung of 1993 films.
WEEKEND AT BERNIE'S 2 is made for a certain audience--the indiscriminate movie-goer who will see almost anything that guarantees a few laughs. Those that belong to that group will find what they're looking for in this film. Almost all the humor is macabre and repetitive, but the film manages to be sporadically funny. Nevertheless, I find it hard to believe that many people will pay $6 or $7 to see a picture that has TV sitcom production values, writing, and acting.
For those who like movies in which corpses get knocked around and banged up, yet still manage to be more engaging than the living people around them, this film will not disappoint. Also, fans of the original WEEKEND AT BERNIE'S will probably be satisfied by this latest (and hopefully last) installment. Everyone else, especially those who restrict their film diet to "good" movies, should stay away (not that many of them would have considered going in the first place).
- James Berardinelli<EMAIL_ADDRESS>.
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


What You're Playing
Your instance
(ex:
https://itabashi.0j0.jp
)
Your token(Required permission to write)
Privacy
save
Save the changes
close
Discard the changes


{% load i18n %}
{% blocktrans %}Name: Set up for identifying a package.{% endblocktrans %}
{% blocktrans %}Tags: Used for identifying and filtering packages.{% endblocktrans %}
{% blocktrans %}Public: Defines whether or not a package can be used by other tenants. (Applies to package dependencies){% endblocktrans %}
{% blocktrans %}Active: Allows to hide a package from the catalog. (Applies to package dependencies){% endblocktrans %}
{% blocktrans %}Description: Allows adding additional information about a package.{% endblocktrans %}


JDM vehicles - meant to be driven in Japan and differ greatly from the cars that Japanese manufacturers build for export. The Japanese car owner looks more toward innovation than long-term ownership which forces Japanese carmakers to refine new technologies and designs first in domestic vehicles.
In 1988, JDM cars were limited to 280 horsepower (PS) (276 hp) and a top speed of 180 km/h (111.8 mph) - limits imposed by the Japan Automobile Manufacturers Association (JAMA) for safety. Many JDM cars have speedometers that register up to 180 km/hb (certain Nissans go up to 190 km/h, and the GT-R has a mechanism that removes the speed limiter on a track) but all have speed limiters.
Popular brands include Honda, Subaru, Toyota, Mazda, Mitsubishi Motors and Nissan with iconic cars such as the Honda S2000, Subaru Impreza WRX STI, Mitsubishi Lancer, Mazda RX-7. Mazda MX-5, Nissan 300ZX, Nissan Skyline GT-R, Honda NSX, Toyota Supra, Nissan 350Z and Civic Type R. Although "true JDM" enthusiasts from Kanjo believe that Civic is the one, that creates JDM style.
Kanjo is the loop of elevated section of the Hanshin Expressway that circles the center of Osaka. When Kanjo is filled with ordinary drivers, Civic fans gather, form relationships and race each other. Why old Honda Civic (produced to 2001)? It's race history on Suzuka Circuit, VTEC engine and small size made it great, simple street race car that was intentionally made for Japanese market.
Tsurikawas - “hang” (tsuri吊) and “leather” (kawa革) - train/subway handle rings stolen in trains by local young gangsters, also known as bosozokus. Originally attached inside cars so passengers could slide their wrist inside the ring and safely hang their body outside the window. They quickly became the symbol of a reckless youth and bosozokus started to attach them outside heavily modified bikes and cars to show rebellion and disrespect to authority. Nowadays, JDM enthusiasts are still flaunting them to express their freedom.


You should receive an email containing a code within a couple minutes. Check your spam folder as well.
You will be automatically redirected back to the login on success


Hello
Letter
Oh look! There's a letter.
OPEN LETTER
×
Happy Mother's Day!
Sending lots of love!
Vianey


Before Change
logger.info("Fetching artifacts")
// TODO rewrite with better artifact management
executor.db._download_dir(
executor.db._get_experiments_keybase() +
experiment.key + "/workspace.tgz",
".")
pass
After Change
if fetch_artifacts:
logger.info("Fetching artifacts...")
for tag, art in experiment.artifacts.iteritems():
if tag == "workspace":
new_local_path = "."
else:
if art["mutable"]:
new_local_path = fs_tracker.get_artifact_cache(
tag,
experiment.key,
)
else:
new_local_path = fs_tracker.get_blob_cache(
art["key"])
art["local"] = new_local_path
executor.db._download_dir(art["local"], art["key"])
executor.run(experiment)
if single_experiment:
logger.info("single_experiment is True, quitting")
return


Pakistan summons Norwegian envoy to protest desecration of Holy Quran
by https://www.dawn.com/authors/5982/naveed-siddiqui, Naveed SiddiquiThe Foreign Office on Saturday summoned the ambassador of Norway to convey the "deep concern" of the government and people of Pakistan over an incident of desecration of the Holy Quran in the Norwegian city of Kristiansand.
During the meeting, Pakistan’s condemnation of the action was reiterated, a statement issued by the FO said.
"It was underscored that such actions hurt the sentiments of 1.3 billion Muslims around the world, including those in Pakistan," the press release said, adding that such actions could not be justified in the name of "freedom of expression".
An anti-Islam rally in Kristiansand had turned violent last week after its leader attempted to set fire to a copy of the Quran despite warnings from police officials.
Videos that surfaced on social media showed a Muslim youth jumping over a fence and kicking the person burning the holy book. Police then intervened and took the anti-Islam protester and the Muslim youth into custody.
The incident drew nationwide condemnation, with many Pakistanis praising the youth as a hero for defending the Quran.
According to the statement, the FO urged the Norwegian authorities to bring those responsible for the act to justice and to "prevent the recurrence of any such incident in the future".
The ambassador of Pakistan in Oslo has also been instructed to convey Pakistan’s protest and deep concern over the incident to the Norwegian authorities, the FO added.


|
DotNetBrowser
1.16
|
Provides access to the DOM event data. More...
Inherits EventArgs.
Public Member Functions | |
| DOMEventArgs () | |
| Initializes a new instance of the DOMEventArgs class. More... | |
| void | PreventDefault () |
| Cancels the event if it is cancelable, without stopping further propagation of the event. More... | |
| void | StopPropagation () |
| Prevents further propagation of the current event. More... | |
Properties | |
| DOMEventType | Type [get] |
| Returns the type of this DOM event. More... | |
| string | EventType [get] |
| Returns a string containing the type of this DOM event. More... | |
| DOMEventTarget | Target [get] |
| Returns the DOMEventTarget to which the event was originally dispatched. More... | |
| DOMEventTarget | CurrentTarget [get] |
| Returns the DOMEventTarget whose DOMEventHandler are currently being processed. More... | |
| DOMEventPhase | EventPhase [get] |
| Used to indicate which phase of event flow is currently being evaluated. More... | |
| bool | Bubbles [get] |
| Used to indicate whether or not an event is a bubbling event. If the event can bubble the value is true, else the value is false. More... | |
| bool | Cancelable [get] |
| Used to indicate whether or not an event can have its default action prevented. If the default action can be prevented the value is true, else the value is false. More... | |
Provides access to the DOM event data.
| DotNetBrowser.DOM.Events.DOMEventArgs.DOMEventArgs | ( | ) |
Initializes a new instance of the DOMEventArgs class.
| void DotNetBrowser.DOM.Events.DOMEventArgs.PreventDefault | ( | ) |
Cancels the event if it is cancelable, without stopping further propagation of the event.
| void DotNetBrowser.DOM.Events.DOMEventArgs.StopPropagation | ( | ) |
Prevents further propagation of the current event.
|
get |
Used to indicate whether or not an event is a bubbling event. If the event can bubble the value is true, else the value is false.
|
get |
Used to indicate whether or not an event can have its default action prevented. If the default action can be prevented the value is true, else the value is false.
|
get |
Returns the DOMEventTarget whose DOMEventHandler are currently being processed.
|
get |
Used to indicate which phase of event flow is currently being evaluated.
|
get |
Returns a string containing the type of this DOM event.
|
get |
Returns the DOMEventTarget to which the event was originally dispatched.
|
get |
Returns the type of this DOM event.


Feature Description - this is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods or any capital letters so i guess this means that it cannot really be considered a paragraph but just a series
This is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods
This is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods
This is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods
This is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods
This is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods USER1
This is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods USER2
This is a simple paragraph that is meant to be nice and easy to type which is why there will be mommas no periods USER3
P1.price / month
Price
P2.price / month
Price
P3.price/ month
Price


|
GrPPI
1.0
Generic and Reusable Parallel Pattern Interface
|
To build GoogleTest and your tests that use it, you need to tell your build system where to find its headers and source files. The exact way to do it depends on which build system you use, and is usually straightforward.
GoogleTest comes with a CMake build script (CMakeLists.txt) that can be used on a wide range of platforms ("C" stands for cross-platform.). If you don't have CMake installed already, you can download it for free from http://www.cmake.org/.
CMake works by generating native makefiles or build projects that can be used in the compiler environment of your choice. You can either build GoogleTest as a standalone project or it can be incorporated into an existing CMake build for another project.
When building GoogleTest as a standalone project, the typical workflow starts with
The above command also includes GoogleMock by default. And so, if you want to build only GoogleTest, you should replace the last command with
If you are on a *nix system, you should now see a Makefile in the current directory. Just type make
to build GoogleTest. And then you can simply install GoogleTest if you are a system administrator.
If you use Windows and have Visual Studio installed, a gtest.sln
file and several .vcproj
files will be created. You can then build them using Visual Studio.
On Mac OS X with Xcode installed, a .xcodeproj
file will be generated.
If you want to use GoogleTest in a project which already uses CMake, the easiest way is to get installed libraries and headers.
find_package
(or pkg_check_modules
). For example, if find_package(GTest CONFIG REQUIRED)
is succeed, you can use the libraries as GTest::gtest
, GTest::gmock
.And a more robust and flexible approach is to build GoogleTest as part of that project directly. This is done by making the GoogleTest source code available to the main build and adding it using CMake's add_subdirectory()
command. This has the significant advantage that the same compiler and linker settings are used between GoogleTest and the rest of your project, so issues associated with using incompatible libraries (eg debug/release), etc. are avoided. This is particularly useful on Windows. Making GoogleTest's source code available to the main build can be done a few different ways:
The last of the above methods is implemented with a small piece of CMake code in a separate file (e.g. CMakeLists.txt.in
) which is copied to the build area and then invoked as a sub-build during the CMake stage. That directory is then pulled into the main build with add_subdirectory()
. For example:
New file CMakeLists.txt.in
:
Existing build's CMakeLists.txt
:
Note that this approach requires CMake 2.8.2 or later due to its use of the ExternalProject_Add()
command. The above technique is discussed in more detail in this separate article which also contains a link to a fully generalized implementation of the technique.
By default, new Visual Studio projects link the C runtimes dynamically but GoogleTest links them statically. This will generate an error that looks something like the following: gtest.lib(gtest-all.obj) : error LNK2038: mismatch detected for 'RuntimeLibrary': value 'MTd_StaticDebug' doesn't match value 'MDd_DynamicDebug' in main.obj
GoogleTest already has a CMake option for this: gtest_force_shared_crt
Enabling this option will make gtest link the runtimes dynamically too, and match the project in which it is included.
An environment that supports C++11 is required in order to successfully build GoogleTest. One way to ensure this is to specify the standard in the top-level project, for example by using the set(CMAKE_CXX_STANDARD 11)
command. If this is not feasible, for example in a C project using GoogleTest for validation, then it can be specified by adding it to the options for cmake via the DCMAKE_CXX_FLAGS
option.
GoogleTest can be used in diverse environments. The default configuration may not work (or may not work well) out of the box in some environments. However, you can easily tweak GoogleTest by defining control macros on the compiler command line. Generally, these macros are named like GTEST_XYZ
and you define them to either 1 or 0 to enable or disable a certain feature.
We list the most frequently used macros below. For a complete list, see file include/gtest/internal/gtest-port.h.
GoogleTest is thread-safe where the pthread library is available. After #include "gtest/gtest.h"
, you can check the GTEST_IS_THREADSAFE
macro to see whether this is the case (yes if the macro is #defined
to 1, no if it's undefined.).
If GoogleTest doesn't correctly detect whether pthread is available in your environment, you can force it with
-DGTEST_HAS_PTHREAD=1
or
-DGTEST_HAS_PTHREAD=0
When GoogleTest uses pthread, you may need to add flags to your compiler and/or linker to select the pthread library, or you'll get link errors. If you use the CMake script, this is taken care of for you. If you use your own build script, you'll need to read your compiler and linker's manual to figure out what flags to add.
GoogleTest is compact, so most users can build and link it as a static library for the simplicity. You can choose to use GoogleTest as a shared library (known as a DLL on Windows) if you prefer.
To compile gtest as a shared library, add
-DGTEST_CREATE_SHARED_LIBRARY=1
to the compiler flags. You'll also need to tell the linker to produce a shared library instead - consult your linker's manual for how to do it.
To compile your tests that use the gtest shared library, add
-DGTEST_LINKED_AS_SHARED_LIBRARY=1
to the compiler flags.
Note: while the above steps aren't technically necessary today when using some compilers (e.g. GCC), they may become necessary in the future, if we decide to improve the speed of loading the library (see http://gcc.gnu.org/wiki/Visibility for details). Therefore you are recommended to always add the above flags when using GoogleTest as a shared library. Otherwise a future release of GoogleTest may break your build script.
In C++, macros don't obey namespaces. Therefore two libraries that both define a macro of the same name will clash if you #include
both definitions. In case a GoogleTest macro clashes with another library, you can force GoogleTest to rename its macro to avoid the conflict.
Specifically, if both GoogleTest and some other code define macro FOO, you can add
-DGTEST_DONT_DEFINE_FOO=1
to the compiler flags to tell GoogleTest to change the macro's name from FOO
to GTEST_FOO
. Currently FOO
can be FAIL
, SUCCEED
, or TEST
. For example, with -DGTEST_DONT_DEFINE_TEST=1
, you'll need to write
GTEST_TEST(SomeTest, DoesThis) { ... }
instead of
TEST(SomeTest, DoesThis) { ... }
in order to define a test.


TRAFFIC (director: Steven Soderbergh; screenwriters: Stephen Gaghan/based on "Traffik" created by Simon Moore, originally produced by Carnival Films for Channel 4 Television (Britain); cinematographer: Peter Andrews (actually the pseudonym of Steven Soderbergh); editor: Stephen Mirrione; cast: Michael Douglas (Robert Wakefield), Don Cheadle (Montel Gordon), Benicio Del Toro (Javier Rodriguez), Luis Guzman (Ray Castro), Dennis Quaid (Arnie Metzger), Catherine Zeta-Jones (Helena Ayala), Steven Bauer (Carlos Ayala), Erika Christensen (Caroline Wakefield), Clifton Collins Jr. (Francisco Flores), Miguel Ferrer (Eduardo Ruiz), Topher Grace (Seth Abrahms), Amy Irving (Barbara Wakefield), Tomas Milian (General Arturo Salazar), Marisol Padilla Sanchez (Ana Sanchez), Jacob Vargas (Manolo Sanchez), Albert Finney (Chief of Staff), D.W. Moffett (Jeff Sheridan); Runtime: 147; USA Films; 2000)
Reviewed by Dennis Schwartz
A big, loopy, overlong, dullish docudrama-style thriller, about the losing battle of the 'War on Drugs.' It is at times more preachy than dramatic, taking the point of view that something has to be done about the drug situation but not saying what, only that what's been tried has not worked and the youth of America are being unduly harmed by drugs. This film calls for a greater emphasis on treatment programs and on mutual cooperation between the Mexican government and the DEA, and more funds to support the effort against a criminal element that has more money, resources, and better weapons than the good guys do. There's nothing new presented here: same old answers, same old film, but this one takes itself more serious because of the talented cast and the formulaic way this story was adapted from a Simon Moore work, which was scripted by Stephen Gaghan and directed with precision but in an uninspiring way by Steven Soderbergh. It first ran as a mini-series on British TV in 1989, a medium it probably would be the most logical place to view this updated ambitious version. The film was devoid of real emotion and played as if the new drug czar was on Larry King piously expounding his beliefs and the drug lords, drug dealers, and drug addicts, were not only slimes and disturbed people, but bores.
The film, to tell its story as coherently as possible (which it manages to do), will criss-cross between southern California, different parts of Mexico, the slums and the rich suburbs of Cincinnati, Ohio, and Washington, DC. The film center itself around conservative Ohio State Supreme Court Justice Bob Wakefield (Michael Douglas), who will be the new drug czar. At each location the characters change, and even though they might never meet, they are connected by their interest in drugs, either to use or sell, or by their efforts to put it off the streets.
The complex multistory will present an overview of the current drug culture, as the drug czar's eyes will widen as he learns about the extent of the problem he is facing. The film's three principal storylines hope to pigeonhole the problem as seen from both sides of the border of law enforcement and from the point of view of earnest law enforcement officials and those who greedily traffic in drugs, and, ultimately, from the direct impact it has on a white, upper-class, suburban family.
The film opens as Tijuana-based cops Javier Rodriguez (Benicio Del Toro) and Manolo Sanchez (Jacob Vargas), halt a drug shipment on a desert road but are then themselves stopped by army general Salazar (Tomas Milian), who seizes the stash.
Bob Wakefield will learn soon after his appointment how vulnerable he is to the drug problem, as his high achiever, sullen 16-year-old daughter, Caroline (Erika Christensen), is getting into heavy drugs (free-basing cocaine) with her creepy, preppie boyfriend (Topher Grace) and some of her classmates, which comes to light after one of their acquaintances overdoses and is brought to the hospital. Bob has lost touch with her by being so busy at his work and his haggard wife (Amy Irving), an experimental drug user herself as a college student, can't relate with her. They are both lost at what to do, but he gets her into a Step Program, involving group therapy as a treatment, but is relocated in the Beltway and can't follow through on how her treatment is going.
 After the successful sting and the arrest of her husband, she turns out to be as ruthless as he is and easily gets involved in trying to fix things so that hubby gets out, even if it takes murdering the witness who is ready to testify against him.
Once all the stories are in place, the film shows how human frailty plays a part in the corruption of various individuals. Helena will do anything to stay rich, as she hires a hit man (Clifton Collins Jr.) to take care of Ruiz. Carlos's snakelike lawyer (Dennis Quaid), who tries to steal three million dollars from his boss while he is behind bars, realizes what will happen to him when found out, but still does it because he craves what the drug kingpin has. Manolo succumbs to being bribed by the drug lords as he is overwhelmed by the money he sees passing hands and does something he would never have done, if not tempted.
The film wraps up neatly, tieing up all the tragic ongoing drug war stories. There was no tension in the air when the drug czar delivers his White House press conference address in a disbelieving tone about how his office will issue a new "10- point plan" to fight drugs. Wakefield has become too demoralized by what has happened to his family, and realizes his words sound hollow, offering the public nothing new. So he asks out loud, How can you wage a war against your own family? The film soft pedals any advocacy for legalizing drugs and offers no hard-hitting critique of current policies, except to say it doesn't work. It seems to have safely placed itself in the middle of the argument, not taking sides (a rather wishy-washy way to leave things).
I don't know what could be said, other than this was a competently made film, the actors were forceful in their roles, with the plucky performance by the conflicted cop Benicio Del Toro outshining the others, and for some comic relief, there was some amusing dialogue between Cheadle and Guzman. The film had a nice look to it, as cinematographer Soderbergh aka Peter Andrews, has given the film a look of urgency, using a handheld camera, and working with different tinctures of desertlike yellow-orange shades and icy blue lighting to get a better view of his subjects and their hard-boiled tale.
REVIEWED ON 2/17/2001 GRADE: C+
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
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