On the server side, Rest.li provides a mechanism to intercept incoming requests and outgoing responses via filters. Each Rest.li filter contains methods that handle both requests and responses.
On the request side, filters can be used for a wide range of use cases, including request validation, admission control, and throttling.
Similarly on the response side, filters can be used for a wide range of use cases, including augmentation of response body and encrypting sensitive information in the response payload.
When using a filter, you have the option of implementing the interface’s onRequest
, onResponse
, and onError
methods - here is where you specify what the filter will do. onRequest is invoked on the request before the actual resource method is invoked. onResponse
is invoked on the response after the resource method is invoked but before being passed to the R2 stack. onError
is invoked when an exception occurs in one of the filter’s methods or if it receives a response error from the previous filter’s onResponse
method. onError
of the first filter in the response filter chain will also be invoked if the REST resource method returns an error.
If you do not implement these methods, the default behavior for each method is to do nothing. For example, you can choose to only implement the onRequest method. This way, on responses or errors, the filter will simply pass the response/error to the next filter.
When a request arrives, the filters intercept it. If onRequest executes successfully, it will pass it to the next filter. If an exception occurs, all subsequent filters are skipped, the filter’s onError
will be invoked, and an error response is passed through the filter chain in reverse and sent back to the client.
When a response is returned from the REST resource method, it is passed into the filter’s onResponse method. If the REST resource method returns an error response, it will be passed into the onError
method instead. If a filter’s onResponse executes successfully, it will pass the response to the next filter. If an exception occurs, the filter will pass it to the next filter’s onError
method.
When onError
is invoked, by default it will pass the error response to the next filter’s onError
method. You can specify additional handling (e.g. logging the error) before passing the response on. You can specify logic to fix the error, whereupon the next filter’s onResponse method will be invoked.
When a Rest.li server is configured to use filters, the filters will be invoked for all incoming requests and outgoing responses of all resources hosted by that server. Therefore, when implementing filters, please keep in mind that filters are cross-cutting and should be applicable to all resources that are hosted by the given Rest.li server.
Creating a concrete filter is simple. All you need to do is implement the com.linkedin.restli.server.filter.Filter
interface.
Rest.li guarantees that for a given request-response pair, the same instance of FilterRequestContext
is made available to both the request filter and response filter.
Each filter method returns a CompletableFuture<Void>
. A CompletableFuture
represents the status result of filter execution and has 3 states - completed, completed with exception, and incomplete. The next filter will not be invoked until the previous filter has completed (either successfully or exceptionally).
If the filter does not call any asynchronous methods, you can simply return CompletableFuture.completedFuture(null)
- this returns an already completed future, and it will cause the filter chain to invoke the next filter.
If there is an error, you can either throw an Exception or return a future that has already called future.completeExceptionally(exception)
- both will do the same thing.
If the filter calls an asynchronous method, you can instantiate an incomplete CompletableFuture and return it from the filter method. This future should be passed into your asynchronous method - when the method finishes, you can call future.complete(null)
. This will trigger the filter chain to invoke the next filter. If there is an error, you can call future.completeExceptionally(exception)
. There are more details on this below.
Not completing a future, whether successfully or exceptionally, will cause the filter chain processing to hang indefinitely.
The implementation of the onRequest
method is free to modify the incoming request. Additionally, it can also reject the incoming request by throwing an exception or completing the future exceptionally - in this case, a response error is automatically passed into the filter’s onError
method.
The onRequest method has access to the FilterRequestContext
. FilterRequestContext
is an interface that abstracts information regarding the incoming request, including the request URI, projection mask, request query parameters, and request headers. Please see documentation of FilterRequestContext
for more info.
After all the filters’ onRequest
method have been successfully invoked, the filter chain passes the request to the Rest.li resource.
The implementation of the onResponse
method can inspect and modify the outgoing response body, HTTP status, and headers. Throwing an exception causes the response to be converted into an error response and passed into the next filter’s onError
method.
The onResponse
method has access to the FilterRequestContext
and FilterResponseContext
. The FilterResponseContext
is an interface that abstracts information regarding the outgoing response, including the response HTTP status, response body, and response headers. Please see documentation of FilterResponseContext
for more info.
After the last filter’s onResponse
method has been invoked successfully, the filter chain passes the outgoing response to the underlying R2 stack. If the last filter’s onResponse
method’s future completes exceptionally, the response is converted into an error response and is passed into the R2 stack.
The implementation of the onError
method handles errors, and has the capability to alter the response body, HTTP status, and headers. The onError method has access to the exception that caused the error, FilterRequestContext
, and FilterResponseContext
.
The CompletableFuture
that is returned by this method should be completed exceptionally unless this filter fixes the error, whereupon the future should be completed successfully. The paradigm is that if an error exists in the response at the end of the filter, the future should be completed exceptionally.
If an exception occurs within the onError
method itself, the next filter’s onError
will be invoked. However, the most recently occurring exception will be passed in as the exception argument.
After the last filter’s onError
method has been invoked, the filter chain passes the outgoing response error to the underlying R2 stack. If the last filter’s onError method’s future completes successfully (i.e. the error was fixed), the error response is converted into a success response and passed to the R2 stack.
import com.linkedin.restli.server.filter.FilterRequestContext;
import com.linkedin.restli.server.filter.FilterResponseContext;
import com.linkedin.restli.server.filter.Filter;
public class RestliExampleFilter implements Filter
{
@Override
public CompletableFuture<Void> onRequest(final FilterRequestContext requestContext)
{
log.debug(String.format("Received %s request for %s resource.", requestContext.getMethodType(), requestContext.getFilterResourceModel().getResourceName()));
return CompletableFuture.completedFuture(null);
}
@Override
public CompletableFuture<Void> onResponse(final FilterRequestContext requestContext, final FilterResponseContext responseContext)
{
System.out.println(String.format("Responding to %s request for %s resource with status code %d.", requestContext.getMethodType(),
requestContext.getFilterResourceModel().getResourceName(), responseContext.getResponseData().getStatus().getCode()));
return CompletableFuture.completedFuture(null);
}
@Override
public CompletableFuture<Void> onError(Throwable t, final FilterRequestContext requestContext, final FilterResponseContext responseContext)
{
log.debug(t.toString());
CompletableFuture<Void> future = new CompletableFuture<Void>();
if (isErrorFixable(t))
{
fixError();
future.complete(null); // success
}
else
{
future.completeExceptionally(t); // could not fix error, so this filter did not execute successfully
}
return future;
}
}
When a request arrives, this filter prints the request type and resource name for every incoming request.
When a response is sent, this filter prints the HTTP response code along with request type and resource name for every outgoing response.
When there is an error, this filter logs the exception that caused it. Notice how the filter has the ability to either fix the error or propagate the error (complete normally vs. complete exceptionally).
The FilterResponseContext
has access to a RestLiResponseData
object. This object contains the response data as a RestLiResponseEnvelope
, which also includes the HTTP status (if success) and the error exception (if error). Besides, it contains headers and cookies, as well as indicators for response type and the resource method.
The RestLiResponseEnvelope
contains the actual data from the response, as well as HTTP status (if success) and the error exception (if error). For example, a GET response would store the retrieved resource data in the envelope.
If there is an error, the exception will never be null but the data stored inside of RestLiResponseEnvelope
will always be null (the envelope itself will not be null, only the data inside of it). The opposite is true if there is no error.
The type of response envelope is based on the Rest.li resource method. For example, a GET response would have data stored in the GetResponseEnvelope
.
| Resource Method | Response Envelope |
|---|---|
GET |
GetResponseEnvelope |
CREATE |
CreateResponseEnvelope |
ACTION |
ActionResponseEnvelope |
BATCH_GET |
BatchGetResponseEnvelope |
BATCH_PARTIAL_UPDATE |
BatchPartialUpdateResponseEnvelope |
BATCH_UPDATE |
BatchUpdateResponseEnvelope |
BATCH_DELETE |
BatchDeleteResponseEnvelope |
BATCH_CREATE |
BatchCreateResponseEnvelope |
GET_ALL |
GetAllResponseEnvelope |
FINDER |
FinderResponseEnvelope |
UPDATE |
UpdateResponseEnvelope |
PARTIAL_UPDATE |
PartialUpdateResponseEnvelope |
OPTIONS |
OptionsResponseEnvelope |
DELETE |
DeleteResponseEnvelope |
Response envelopes are grouped together based on ResponseTypes
. Each response type shares the same data format, and thus use the same getters and setters. A parent response envelope is subclassed by the envelopes in the same ResponseType group.
For example, GetResponseEnvelope
, ActionResponseEnvelope
, and CreateResponseEnvelope
all store a RecordTemplate
and all use getRecord
and setRecord
as their data access methods. As such, RecordResponseEnvelope
is the parent envelope for all three. Grouping them together this way reduces code duplication because you can write code for all envelopes that share the same interface.
| Response Type | Parent Response Envelope | Child Response Envelopes |
|---|---|---|
SINGLE_ENTITY |
RecordResponseEnvelope |
GetResponseEnvelope , CreateResponseEnvelope , ActionResponseEnvelope |
CREATE_COLLECTION |
N/A - only one envelope falls under this response type, so no need for parent |
BatchCreateResponseEnvelope |
GET_COLLECTION |
CollectionResponseEnvelope |
GetAllResponseEnvelope , FinderResponseEnvelope |
BATCH_ENTITIES |
BatchResponseEnvelope |
BatchGetResponseEnvelope , BatchUpdateResponseEnvelope , BatchPartialUpdateResponseEnvelope , BatchDeleteResponseEnvelope |
STATUS_ONLY |
EmptyResponseEnvelope |
PartialUpdateResponseEnvelope , UpdateResponseEnvelope , DeleteResponseEnvelope , OptionsResponseEnvelope |
A typical use case is as follows - notice there are 2 ways to handle different response data types, the first using the resource method and the second using the response type:
public class RestliExampleFilter implements Filter
{
@Override
public CompletableFuture<Void> onResponse(FilterRequestContext requestContext, FilterResponseContext responseContext)
{
RestLiResponseData<?> responseData = responseContext.getResponseData();
switch (responseData.getResourceMethod())
{
// Example showing determining code path based on resource method (CREATE, GET, etc.)
case CREATE: // Handle CREATE response
CreateResponseEnvelope envelope = (CreateResponseEnvelope) responseData.getResponseEnvelope();
someMethod(envelope.getStatus());
anotherMethod(envelope.getRecord());
envelope.setRecord(new EmptyRecord()); //Modify the response
break;
case GET // Handles GET responses
break;
default:
// Other types available as well.
}
// Another example, this time showing determining code path based on response type (SINGLE_ENTITY, GET_COLLECTION, etc.)
switch (responseData.getResponseType())
{
case SINGLE_ENTITY: // Handle GET, ACTION, and CREATE responses - note how you can apply the same logic to all 3 because they share the same data access interface
RecordResponseEnvelope envelope = (RecordResponseEnvelope) responseData.getResponseEnvelope();
someMethod(envelope.getRecord());
envelope.setRecord(new EmptyRecord()); //Modify the response
break;
case GET_COLLECTION // Handles GET_ALL and FINDER responses
break;
default:
// Other types available as well.
}
return CompletableFuture.completedFuture(null);
}
}
Rest.li supports chaining of filters. When a Rest.li server is configured to use multiple filters, the filters are ordered in the same order specified in the RestLiConfig
. On requests, filters that are declared closer to the beginning are invoked first. On responses, filters that are declared closer to the end are invoked first. See diagram at top of document for visualization.
Approach 1 to chain three filters.
final RestLiConfig config = new RestLiConfig();
config.addFilter(new FilterOne(), new FilterTwo(), new FilterThree());
Approach 2 to chain three filters.
final RestLiConfig config = new RestLiConfig();
config.addFilter(new FilterOne());
config.addFilter(new FilterTwo());
config.addFilter(new FilterThree());
Approach 3 to chain three filters.
final RestLiConfig config = new RestLiConfig();
config.addFilter(Arrays.asList(new FilterOne(), new FilterTwo(), new FilterThree()));
Approach 4 to chain three filters
<bean class="com.linkedin.restli.server.RestLiConfig">
<property name=“filters>
<list>
<bean class=“FilterOne”/>
<bean class=“FilterTwo”/>
<bean class="FilterThree”/>
</list>
</property>
</bean>
It is recommended that Rest.li filters be stateless. To facilitate transfer of state between filters, Rest.li provides a scratch pad in the form of a Java Map. This scratch pad can be accessed via the getFilterScratchpad
method on the FilterRequestContext
. See below for an example Rest.li filter that computes the request processing time and print it to standard out.
The manner in which exceptions are handled in the filter’s request vs. response methods are different.
There are 2 ways a filter can invoke an exception:
future.completeExceptionally(throwable)
If an exception is thrown while processing a request or if the future is completed exceptionally, further processing of the request is terminated and the filter’s onError method is invoked. In other words, in order for the incoming request to reach the resource implementation, invocation of all filters’ onRequest
methods needs to be successful.
Exception/error handling in the context of response filters is a little more involved than in the case of request filters. Response filters are applied to both successful responses as well as all types of errors.
Such errors can include:
NullPointerException
or RestLiServiceException
.CollectionResult
).Subsequently, response filters can transform a successful response from the resource to an error response and vice versa. In addition, a successful response from a filter earlier in the filter chain can be transformed into an error response and vice versa by filters that are subsequent in the filter chain.
The exception/error handling behavior of response filters is summarized as follows:
onError
method is invoked. You can specify error handling in the onError method (i.e. fix the error or propagate it to the next filter).When an exception occurs, the HTTP status code will be automatically set according to this rule:
RestLiServiceException
, the status will be taken from the exception.It is recommended that filters throw a RestLiServiceException
.
Note that response headers will be maintained if an exception is thrown, however some new headers signifying an error may be added.
Situations may arise where you may need to make external calls within your filter code. Say for example, there’s an external Auth service that your service integrates with. Every call that comes to your service should be first routed to the Auth service for approval, and only if the Auth service give you a green light, can your resource process the request. Let’s say you have a RestLi filter that abstracts away the invocation of the Auth service. One way to implement this Auth filter is as follows:
import com.linkedin.restli.server.filter.FilterRequestContext;
import com.linkedin.restli.server.filter.Filter;
public class AuthFilter implements Filter
{
@Override
public CompletableFuture<Void> onRequest(FilterRequestContext requestContext)
{
String resourceName = requestContext.getResourceModel().getResourceName();
// Now invoke the auth service.
Request<Permission> getRequest = builders.get().resourceName(resourceName).build();
Permission permission = getClient().sendRequest(getRequest).getResponse().getEntity();
log.debug(String.format("Received permission %s from auth service for request for %s resource.",
requestContext.getMethodType(), resourceName));
if (permission.isGranted())
{
// Since we have permissions, pass the request along.
return CompletableFuture.completedFuture(null);
}
else
{
throw new RestLiServiceException(HttpStatus.S_401_UNAUTHORIZED, "Permission denied");
}
}
}
The above implementation makes a synchronous call to an external auth service to authenticate the incoming request. Although the above implementation is functionally correct, it is not very efficient. Upon close investigation, you’ll observe that the request processing thread of your service is now blocked on an outgoing call to the auth service. If the auth service is slow to respond to requests, very soon it’s possible that all threads of your service is blocked waiting for response from the auth service.
The Rest.li filters provide a CompletableFuture interface that handles the asynchronous callbacks for you. The implementation is shown below:
import com.linkedin.restli.server.filter.FilterRequestContext;
import com.linkedin.restli.server.filter.Filter;
public class AuthFilter implements Filter
{
@Override
public CompletableFuture<Void> onRequest(FilterRequestContext requestContext)
{
CompletableFuture<Void> future = new CompletableFuture<Void>();
String resourceName = requestContext.getResourceModel().getResourceName();
// Now invoke the auth service.
Request<Permission> getRequest = builders.get().resourceName(resourceName).build();
Callback<Response<Permission>> cb = new Callback<Response<Permission>>()
{
@Override
public void onSuccess(Response<Permission> response)
{
Permission permission = response.getEntity();
log.debug(String.format("Received permission %s from auth service for request for %s resource.",
requestContext.getMethodType(), resourceName));
if (permission.isGranted())
{
// Since we have permissions, pass the request along.
future.complete(null);
}
else
{
future.completeExceptionally(new RestLiServiceException(HttpStatus.S_401_UNAUTHORIZED, "Permission denied"));
}
}
@Override
public void onError(Throwable e)
{
future.completeExceptionally(new RestLiServiceException(HttpStatus.S_500_INTERNAL_SERVER_ERROR, e));
}
}
// Invoke the auth service asynchronously.
getClient().sendRequest(getRequest, requestContext, cb);
return future;
}
}
The above implementation makes an asynchronous blocking call to the external auth service to authenticate the incoming request. In this implementation, the request processing thread of your service is NOT blocked on an outgoing call to the auth service and is free to process more incoming requests for your service. By using CompletableFuture
, you can make outgoing asynchronous calls from within RestLi filters.


US appears to be reviewing options for success of NK talks: minister
WASHINGTON -- The United States appears to be reviewing various options for the success of denuclearization negotiations with North Korea, Seoul's unification minister said Monday.
Kim Yeon-chul made the remark to reporters after meeting with US Special Representative for North Korea Stephen Biegun in Washington. He declined to elaborate.
Denuclearization negotiations between Washington and Pyongyang have stalled since February's second summit between US President Donald Trump and North Korean leader Kim Jong-un ended without a deal.
The North has threatened to seek a "new way" unless the US comes up with an acceptable offer before the end of the year.
"The US appears to be reviewing various options for the success of these negotiations," the minister said. "It's a sensitive period, so I'd rather not speak in detailed terms."
The minister was answering a question about North Korea's latest statement rejecting talks with the US.
Kim Yong-chol, a former nuclear negotiator for Pyongyang, said earlier Monday that the US "should not even dream of" having denuclearization negotiations with the North before it withdraws its "hostile" policy.
He also scoffed at Sunday's decision by South Korea and the US to postpone combined military exercises in support of diplomatic efforts to denuclearize the North, saying Pyongyang wants them stopped completely.
The minister, who oversees inter-Korean relations, said he and Biegun had candid and wide-ranging discussions on the current state of South-North ties, including the issue of the now-suspended tourist resort on North Korea's Mount Kumgang.
North Korea has threatened to tear down all South Korean-built facilities at the resort, saying it will establish its own tourism zone there.
The US has been reluctant to support full-fledged inter-Korean economic activity out of concern it could undermine international sanctions on Pyongyang.
"We explained our ideas on the Mount Kumgang tourism project, as well as other inter-Korean issues," Kim, the minister, said.
"There are many areas that need to be discussed. ... I believe we will have another opportunity to have such discussions soon."
Kim is scheduled to deliver a keynote address at a forum in Washington on Wednesday. (Yonhap)


TeamCity has been proving to be one of the most useful tools I have used in recent times. It has helped me from continuous deployment of sites to staging and production environments, allowing security penetration testing, running automated acceptance tests with SpecFlow and much more. I really hoped there would be a way that I could test the SEO capabilities of a newly deployed site. Usually when I deploy a site I will open IIS console and run a Site Analysis against the URL using the SEO Toolkit but I thought there must really be a way to run this from TeamCity.
Over the past week or so I have been writing some prototype code that will allow me to use the SEO toolkit dll to create a sits analysis. This worked out to be effective and since I was able to run the analysis from code I was able to run the application from TeamCity.
the code for this application is in very early stages as it was written with the help of some sample code on MSDN. It will evolve over time and I’ll make this available. The plans for the application are to support different parts of the analysis to be added to the report by config parameters. As I am sure this code could be misused I have added a small Thread.Sleep so that it can’t be used to DoS attack a site. I accept no responsibilities for the code being misused.
Configuring TeamCity to Run the Application
Log into TeamCity as an administrator and go into the administration screen.
Click on ‘Create Project’ and enter some project details:
Next we want to create a build configuration. So click on ‘Create build configuration’:
Add some general details – name, description and build number format. The most important thing to note here is the artifacts text area. It has SEOReport.html added to it. This is the report that the crawler application creates. We add this to the artifacts so that we can add the results to a report tab.
We will be asked next to enter some VCS settings. I have had to hack things slightly. Technically I don’t have to check this application out of version control. So I enter the path to the application file in the checkout path as follows:
The build step is the next thing to add. In the build steps over click on Add Build Step and choose Command Line from the runner type drop down menu. This is where we call the application now:
As you can see we leave the working directory empty as we have specified the directory already in the VCS stage. We can then call the .exe from the command executable. The parameters is where it gets interesting. This is were we pass in the site to scan – if a site is not specified then an application exception will be thrown and the build will fail.
When you have finished the setup and passed in a site then run the build. On a successful build the build details page will show (a newly configured) SEO Crawler Report tab:
If you don’t know how to add a custom report tab I’ll cover this in a separate post. But on the successful build and we click that tab we get a very simple report as follows:
This report only has a summary of URLS, links and violations as well as site status codes and broken links. But as this application provides a full scan that the SEO toolkit can do we can make the application output more details. In coming versions of the code, I’ll allow it to be configurable as to which sections can be added to the report.
How Can I View The Full Report?
As I mentioned, the crawler application does a full site analysis. The same analysis that IIS does. In the application root folder an IIS SEO Reports folder. This folder will contain all the scan reports. So if you really want to you can take the scan folder and drop it to a know IIS location (for me is MyDocuments/IIS SEO Reports) and IIS can display the full report as it would have done before.
Another tip of the cap to TeamCity. I know as this is an executable it can be called from any build script but its just made very easy for me with the build in build runner and parameters acceptance.


Build Instructions¶
Build in Linux/Unix¶
Start by cloning the git repository into a suitable location on you computer
git clone git@github.com:oystelan/CFDwavemaker.git
open a terminal and navigate to the location of the CFDwavemaker folder. a Makefile is provided for quick building. The following make commands are available:
Multi-threading OpenMP builds¶
Make both static (.a) and shared (.so) library with OpenMP parallel support
make openmp
Other commands¶
As usual,
make clean
will remove all previously combiled object files (.o) which are used when assembling the library
Warning
A few words of advice:
Be sure to run “make clean” before running either “make openmp” or “make all”
Be careful/try to avoid using the OpenMP compiled library in combination with MPI.


MockURLProtocol
public final class MockURLProtocol : URLProtocol
Subclass of URLProtocol used to intercept requests
-
Errors that can be returned in the response via startLoading()
See moreDeclaration
Swift
public enum MockURLProtocolError : Swift.Error
-
If the request URL doesn’t exist as a key in the mocks dictionary, then MockURLProtocol won’t assert that it can handle the request
Declaration
Swift
public class func canHandle(url: URL) -> Bool
-
Will return true if canHandle(url:) returns true. Returns false if the task has no url.
Declaration
Swift
override public class func canInit(with task: URLSessionTask) -> Bool
-
Will return true if canHandle(url:) returns true. Returns false if the request has no url.
Declaration
Swift
override public class func canInit(with request: URLRequest) -> Bool
-
Returns the request unmodified.
Declaration
Swift
override public class func canonicalRequest(for request: URLRequest) -> URLRequest
-
Always returns false
Declaration
Swift
override public class func requestIsCacheEquivalent(_ a: URLRequest, to b: URLRequest) -> Bool
-
This method retrieves a mock and returns a response based on the configruation it contains.
Declaration
Swift
override public func startLoading()
-
This method does nothing as we aren’t initiating any network requests
Declaration
Swift
override public func stopLoading()


--- layout: default nav: why ---
Intercooler is a Partial View Controller client-side framework: it communicates with the server via AJAX, but rather than expecting JSON responses it expects fragments of HTML (i.e. Partial Views), which are then loaded into the DOM directly.
This is in contrast with more traditional client side MVC frameworks such as Ember.js or Angular.js which communicate with the server using JSON requests and JSON responses.
Here is a diagram how a PVC framework works:
Note that the response content is a partial bit of HTML, and it is swapped in place of the target div.
Intercooler formalizes this approach, using HTML5-style attributes to drive the AJAX requests.
Other examples of PVC-like frameworks are Turbolinks and pjax.
The primary advantages of PVC frameworks is their simplicity: they preserve many of the advantages, advances, tools and concepts of traditional server-side web applications and can often involve only slight modifications to existing applications to move over to.
This is in contrast to most Javascript MVC frameworks, which are very heavyweight. They give you a lot, but they require a lot as well: you must set up a client side model, manage routing, use client-side templates, etc. You are going to have to write a fair bit of Javascript to get things rolling.
Depending on how you implement things, you are going to probably have a bunch of server side logic lying around as well.
A PVC framework, on the other hand, keeps the majority of your logic on the server side. Depending on the framework, you end up writing only a bit more code than you would in a more traditional web application and, since everything is still rendered server side, you eliminate the need for heavy client-side work.
Both TurboLinks and pjax are targeted PVC frameworks: they are mostly concerned with navigation.
Intercooler is a more complete PVC framework: there are patterns for updating things as small as a progress bar width, for polling, for passing actions to the server, for working with tables/bulk operations, refreshing specific elements in the DOM, etc.
One way to think about Intercooler is as an Angular alternative, with REST-ful bindings to a server side model & renderer.
And a lot less code.
The core concepts in Intercooler are:
Sure, as you should be. This is an as-yet uncodified approach to building web applications. However, many successful web applications are already being built this way. Basecamp, for example, is a famous one. It doesn't use Intercooler, of course, but it does use the PVC-style.
And this approach isn't right for every UI: if you have a bunch of stuff flying around on your UI and lots of user input patterns, Intercooler isn't the right thing. However, even in applications like that you probably have some plain old form or table UI's sitting around for which a full Javascript MVC framework is overkill. There, Intercooler can help.
Great! On to the introduction!


Loads a TensorFlow plugin, containing custom ops and kernels.
tf.compat.v1.load_op_library
tf.compat.v2.load_op_library
tf.load_op_library(library_filename)
Pass "library_filename" to a platform-specific mechanism for dynamically
loading a library. The rules for determining the exact location of the
library are platform-specific and are not documented here. When the
library is loaded, ops and kernels registered in the library via the
REGISTER_*
macros are made available in the TensorFlow process. Note
that ops with the same name as an existing op are rejected and not
registered with the process.
library_filename
: Path to the plugin.
Relative or absolute filesystem path to a dynamic library file.A python module containing the Python wrappers for Ops defined in the plugin.
RuntimeError
: when unable to load the library or get the python wrappers.


Duration
15 minutes
Goals
This exercise will show how to begin providing unit tests to your View Models. If you are new to unit testing, then make sure to take the XTC101 - Intro to Unit Testing class.
Assets
This lab is a continuation of the previous exercise. You can your existing project or the completed solution in the Part 04 Resources folder.
There is a completed solution in the Part 05 Resources folder.
Note - the provided completed solution uses MSTest as the test runner. As a result, the test project will only work in Visual Studio on Windows. You can follow the steps below using NUnit to run the tests on macOS.
Steps
Create service abstractions
Our first step is to provide some abstractions over the coupled dependencies we are using in the classes we want to test. This means creating some interfaces so we can mock them out in our unit tests to control the behavior. In this case, we have to abstract out the static DependencyService
class. The IMessageVisualzer
, and INavigationService
abstractions are already in our infrastructure library.
In this case, the XamarinUniversity.Infrastructure library has an abstraction for DependencyService as well. It looks like this:
public interface IDependencyService { T Get() where T : class; }
In addition, there is a wrapper class which uses DependencyService
to provide the above implementation. It's very simple:
public class DependencyServiceWrapper : IDependencyService { public T Get() where T : class { return DependencyService.Get<T>(); } }
You could easily do this abstraction yourself - and you might want to if you decided to use a different Service Locator implementation. However, for simplicity, we'll use this version. You would need to do this same abstraction for each concrete type you need to be able to mock out or replace for testing purposes.
Change the code to use the abstractions
We have one step before we can start building unit tests - we need to use the DependencyService
abstraction instead of the real implementation.
-
Open the MainViewModel.cs file in ViewModels. It uses the Xamarin.Forms
DependencyService
, but to unit test it, we need it to use ourIDepdendencyService
instead. In addition, the unit test needs to replace the implementation so it has control of it.
Ideally, we'd pass in theIDependencyService
into the constructor so we are using dependency injection to get the service but there's a problem with that. In this case, ourMainViewModel
is being created by theDependencyService
class from our registration in App.xaml.cs. The problem is there's no way to customize that creation - the class must have a default constructor!
This is a common problem when retrofitting classes for unit testing, and it turns out there's an easy solution. Create two constructors - one that takes theIDependencyService
interface, and another, default one, that passes ourDependencyServiceWrapper
to the first.
Our code will continue to use the default constructor to create the view model, and that constructor will then pass in a valid service to the parameterized form. Our unit tests will simply use the parametrized form directly. This is a fairly neat and elegant solution to the problem. Make sure to save the passed interface off in a field in the view model.
-
Go through the
MainViewModel
and replace theDependencyService
usage with your new field. -
We are using
DependencyService
in a few other places, but we don't have to change all of them. For example, the App.xaml.cs code uses it to wire everything up - we won't be unit testing that functionality (since it's Xamarin.Forms infrastructure pieces). But some places we will want to also fix - the other place we are using theDependencyService
is in theQuoteManager
. Open the source file (QuoteManager.cs in the Data folder) and change it to pass in theIQuoteLoader
to the two methods.
IDependencyService
here and have each method look up what it needs. However, this makes it a bit harder to see what the methods actually depend on, so when there is a limited number of dependencies, it's generally recommend to inject/pass in exactly what's really needed. But, it's certainly a valid approach.
-
Modify the two spots where QuoteManager.cs is used to lookup the
IQuoteLoader
and pass it in. The first is in theMainViewModel
constructor and the second is in the App.xaml.csOnSleep
method. In the latter case, you can just use the normalDependencyService
since we won't test this method directly (it's protected and called by the framework). - Build and run the application to make sure it's all still working with our abstractions in place. Once everything looks good, it's time to start writing some unit tests!
Creating the Unit Test project and mocks
Now we are ready to start creating tests. Let's begin by creating the test project.
- If you are using Visual Studio for Mac, add a new NUnit Library Project to your solution. This is found under Other > .NET > NUnit Library Project. If you are using Visual Studio, then the default testing library is MSTest; you can use NUnit but it requires an optional extension and project templates. For MSTest, add a new Unit Test Project to the solution - this is found under the Visual C# > Test category in Visual Studio.
- Add a reference to the GreatQuotes assembly - this is the one we want to test as it has most of our code and logic in it.
- Since that assembly depends on the XamarinUniversity.Infrastructure types, add a NuGet reference in the unit test project to that package. This will also drag in Xamarin.Forms, but we won't actually write any tests or use any types from that assembly.
- Since we want to mock out out services, create a folder named Stubs in the test project. We'll place all our "mocks" here.
-
We want to work with some sample quotes - but not necessarily with the real database (unit tests shouldn't talk to a real database). So, let's start by mocking out the
IQuoteLoader
. Create a class named QuoteLoaderStub in the Stubs folder. -
Have the class implement
IQuoteLoader
. We could just fill it in with some sample data in an internal list, but it's tedious to create sample data - especially when there are tools to do that for us. - Add a Nuget reference to the AutoFixture package. Then use the following implementation for your QuoteLoaderStub:
-
Next, let's implement the
IDependencyService
stub. Create a new source file named DependencyServiceStub in the Stubs folder and use the following (simple) implementation to hold our services: -
Next, implement the
IMessageVisualizerService
stub. In this case we want to know when the service is invoked (to be able to test that a message was displayed). We could make this as complex as we like, controlling setup and outcome, but for simplicity, let's start with this implementation: -
Using
Task.FromResult
allows us to conform to the async nature of the real service, but not actually use any additional threads (so we don't have to work about synchronizing it back to our unit test). -
Finally, use the following implementation for the
INavigationService
stub:
using GreatQuotes.Data; using System.Collections.Generic; using System.Linq; using Ploeh.AutoFixture; namespace GreatQuotes.Tests.Unit { public class QuoteLoaderStub : IQuoteLoader { private IList<GreatQuote> quotes; public QuoteLoaderStub () { quotes = new Fixture() .CreateMany<GreatQuote>(20) .ToList(); } public IEnumerable<GreatQuote> Load() { return quotes; } public void Add (GreatQuote quote) { quotes.Add (quote); } public void Save (IEnumerable<GreatQuote> quotes) { } } }
public class DependencyServiceStub : IDependencyService { readonly Dictionary<Type, object> registeredServices = new Dictionary<Type, object>(); public void Register<T>(object impl) { this.registeredServices[typeof(T)] = impl; } public T Get<T> () where T:class { return (T)registeredServices[typeof(T)]; } }
public class MessageVisualizerServiceStub : IMessageVisualizerService { public bool ShowMessageWasCalled { get; set; } public Task<bool> ShowMessage(string title, string message, string ok, string cancel = null) { ShowMessageWasCalled = true; return Task.FromResult(true); } }
public class NavigationServiceStub : INavigationService { public object CurrentPage { get; set; } public Task NavigateAsync(object pageKey, object viewModel = null) { this.CurrentPage = pageKey; return Task.FromResult(0); } public bool CanGoBack { get; set; } public Task GoBackAsync() { return Task.FromResult(0); } public Task PushModalAsync(object pageKey, object viewModel = null) { throw new NotImplementedException(); } public Task PopModalAsync() { throw new NotImplementedException(); } }
Setup the Test Environment
We're almost ready to start writing some tests! Before we do, let's setup our mock environment.
using
statements which allow you to switch back and forth by defining a #define
at the top of the file. Check that final solution out if you are interested in seeing how to support both testing frameworks with one codebase.
-
Open the single test file (or create a new source file if one was not included in your project). Rename or name the file "MainViewModelTests". Make sure your class is decorated with a
[TestFixture]
attribute. -
Add a method named
Setup
to the class and decorate it with the[OneTimeSetUp]
attribute. This will cause it to be run before any tests are executed. -
Create a new
DependencyServiceStub
and register the three services we need (IQuoteLoader
,INavigationService
andIMessageVisualizerService
). Make sure to use our stub implementations. -
Save the
DependencyServiceStub
in an instance field of the class.
Write the first unit test
Let's start out by creating a simple unit test to verify that the MainViewModel
loads 20 quotes from our dummy quote Loader. If the template included a sample method, you can replace or remove it.
-
Create a new test method named
MainViewModel_Should_load_quotes_with_new_vm
. The long name ensures we know what's being tested when we look in the Unit Test runner window. - Decorate the class with a
[Test]
attribute. -
Create a new
MainViewModel
and pass it our mocked out dependency service field. -
Verify that we have 20 quotes in the
Quotes
collection. We don't care about the _contents_ of those quotes since they were randomly generated, all we are looking for here is the quantity.
- Run the test and verify that it passes.
-
Open the single test file (or create a new source file if one was not included in your project). Rename or name the file "MainViewModelTests". Make sure your class is decorated with a
[TestClass]
attribute. -
Add a static method named
Setup
that takes aTestContext
to the class and decorate it with the[AssemblyInitialize]
attribute. This will cause it to be run before any tests are executed. -
Create a new
DependencyServiceStub
and register the three services we need (IQuoteLoader
,INavigationService
andIMessageVisualizerService
). Make sure to use our stub implementations. -
Save the
DependencyServiceStub
in an instance field of the class.
Write the first unit test
Let's start out by creating a simple unit test to verify that the MainViewModel
loads 20 quotes from our dummy quote Loader. If the template included a sample method, you can replace or remove it.
-
Create a new test method named
MainViewModel_Should_load_quotes_with_new_vm
. The long name ensures we know what's being tested when we look in the Unit Test runner window. - Decorate the class with a
[TestMethod]
attribute. -
Create a new
MainViewModel
and pass it our mocked out dependency service field. -
Verify that we have 20 quotes in the
Quotes
collection. We don't care about the _contents_ of those quotes since they were randomly generated, all we are looking for here is the quantity.
- Run the test and verify that it passes.
Add more tests
Here are some other tests we might add into the project -- the Completed project has all of these filled out:
| Method | Description |
|---|---|
| MainViewModel_AddQuote _should_go_to_edit_page |
This should execute the AddQuote command and verify that the navigation service stub is on the AppPage.EditPage . |
| MainViewModel_AddQuote _should_go_add_selected_quote |
This should execute the AddQuote command and verify that it adds a new quote to the Quotes collection. |
| MainViewModel_EditQuote _should_go_to_edit_page |
This should execute the EditQuote command and verify that the navigation service stub is on the AppPage.EditPage . |
| MainViewModel_EditQuote _should_go_to_edit_page |
This should execute the EditQuote command and verify that the navigation service stub is on the AppPage.EditPage . |
| MainViewModel_DeleteQuote _should_show_message |
This should execute the DeleteQuote command and verify that the message visualizer service mock was called. |
| MainViewModel_DeleteQuote _should_remove_quote |
This should execute the DeleteQuote command and verify that the passed quote is removed from the Quotes collection. |
| MainViewModel_DeleteQuote _should_set_next_quote_as_selected |
This should execute the DeleteQuote command, passing the first quote in the Quotes collection and verify that when it returns, the SelectedQuote property is set to the next quote in the list. |
(Optional) Dealing with asynchronous code
You might recall that the commands are all asynchronous because they rely on either the INavigationService
and the IMessageVisualizerService
. If we relied on the real services, this would be a problem because the test wouldn't know when these async tasks are completed. There are two ways to handle this:
-
Remove the async nature from the command. This is essentially what we've done here - we mocked out the services to return a
Task
but not be async. That means the tasks are completing on the thread they are started on and when the calls to the command returns, the function itself was completely done. This is a guaranteed optimization of theasync/await
functionality in C# that we can take advantage of here. -
Provide a way to access the
Task
being returned by the commanding methods. You could do this by testing the methods directly (instead of the commands), or by deriving fromCommand
and providing another method that returns theTask
which your unit tests would use - abstract it behind an interface for generalization. The XamarinUniversity.Infrastructure library has just an abstraction names IAsyncDelegateCommand which looks like this: - It also has an implementation of this named AsyncDelegateCommand which provides the necessary method.
-
Your View Model code could use this abstraction and implementation to expose the commands and the unit test could then use the
IAsyncCommand
to get the returningTask
andawait
on it so the test waits for the asynchronous operation to complete before continuing. You can try the above approach out by changing the message visualization service to have aTask.Delay
in it to simulate a pause for user interaction. This will break all of the DeleteQuote unit tests because the command will return before the method is complete.
public interface IAsyncDelegateCommand : ICommand { Task ExecuteAsync(object parameter); }
The project in the Final directory has asynchronous support.
(Optional) refactor our core code
Currently, we are running tests on the PCL associated with the Xamarin.Forms application. That means we are seeing other types we can't test such as XAML files and visual things. In addition, because the View Models are using the Command
object, we have an inherent tie to Xamarin.Forms in each View Model. We can restructure the project to break these dependencies so that all the tested code lives in a "core" assembly and the Unit Test project tests all the elements in that project. This allows us to see full code coverage statistics because we have isolated the testable pieces. The project in the Final folder has a restructured version of the app.
Summary
In this demonstration, we've created some unit tests for our View Model by adding a new unit test library, creating abstractions for the code dependencies and then mocking out those abstractions in our unit tests. There is a completed version of the project in the Part 05 Resources folder. In addition, there is a Final project in Part 05 Resources which has the completely separated code into UI and Core using the approaches outlined above.


:: com :: sun :: star :: rendering ::
|
| struct RenderState |
|
- Description
- This structure contains information passed to each
XCanvas render operation.
This structure contains information considered as the render
state, i.e. the common setup required to render each individual
XCanvas primitive.
- Since
- OOo 2.0
|
| Elements' Summary |
| AffineTransform |
The affine transform associated with this render
operation. |
| Clip |
The clipping area associated with this render operation. |
| DeviceColor |
The device color associated with this render operation. |
| CompositeOperation |
The composition mode associated with this render
operation. |
| Elements' Details |
AffineTransform
::com::sun::star::geometry::AffineMatrix2D AffineTransform;
- Description
- The affine transform associated with this render
operation.
This is used to transform coordinates of canvas primitives
from user space to view space (from which they are
subsequently transformed to device space by the view
transform).
|
|
Clip
XPolyPolygon2D Clip;
- Description
- The clipping area associated with this render operation.
This clipping is interpreted in the user coordinate system,
i.e. subject to the render state transform followed by the
view transform before mapped to device coordinate space.
Specifying an empty interface denotes no clipping,
i.e. everything rendered to the canvas will be visible
(subject to device-dependent constraints, of
course). Specifying an empty XPolyPolygon2D, i.e. a
poly-polygon containing zero polygons, or an XPolyPolygon2D
with any number of empty sub-polygons, denotes the NULL
clip. That means, nothing rendered to the canvas will be
visible.
|
|
DeviceColor
sequence< ColorComponent > DeviceColor;
- Description
- The device color associated with this render operation.
Note that this need not be RGB here, but depends on the active
device color space.
- See also
- XGraphicDevice, XColorSpace
|
|
CompositeOperation
byte CompositeOperation;
- Description
- The composition mode associated with this render
operation.
The composite mode determines in which way the primitive and
possibly existing background is combined. The permissible
values must be one out of the CompositeOperation
constants.
|
|
Top of Page
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


Defining the Stage Layout
Next we define the layout of the stage.
Steps:
- Copy or enter the text from the right into the file
You can specify:
- the type
- The types are: Menu, Panel, SplitPane, Stage, and Window
- name, so that we can refer to it later on when we define our pages
- what the menu bar of this stage will contain
- The options are: NO_TASK_BAR, TOP_TAB_TASK_BAR, TOP_BLOCK_TASK_BAR, LEFT_BLOCK_TASK_BAR, RIGHT_BLOCK_TASK_BAR, BOTTOM_BLOCK_TASK_BAR, and ALLOW_NEW_PANEL
- In our case we need to have the TOP_TAB_TASK_BAR because we need the tab to switch between the four windows, and we would like it at the top
- margins
- the type of title bar
- The options are: NO_TITLE_BAR, WINDOW_CONTROLS_OUTSIDE_OF_TITLE, and WINDOW_CONTROLS_INSIDE_OF_TITLE
- In our case we need to have the NO_TITLE_BAR because we want the title to show up next to the navigation icons, to take up as little space as possible
- what navigation buttons you'd like on your stage
- The options are: NO_NAV_BAR, NAV_FORWARD_BUTTON, NAV_RELOAD_BUTTON, NAV_ADDRESS_BAR, and TAB_PERSISTENCE_FLAG
- In our case we need to have the:
- NAV_BACK_BUTTON + NAV_FORWARD_BUTTON so that the user can navigate back and forward when they load detail views to the bottom panel
- NAV_RELOAD_BUTTON so that the user can reload a window within the stage
- what controls are offered for the window
- The options are: NO_TITLE_BAR_OPTIONS, TITLE_BAR_QUESTION_MENU, TITLE_BAR_MINIMIZE_BUTTON, TITLE_BAR_HIDE_BUTTON, and TITLE_BAR_CLOSE_BUTTON
- In our case we need to have the NO_TITLE_BAR_OPTIONS because we specifed that we wanted no title bars above
- whether you want it to be resizable
- The options are: WINDOW_IS_SIZABLE, WINDOW_IS_FIXED, and WINDOW_IS_FULL
- In our case we need to have the WINDOW_IS_FULL because we want the window to take up the whole window container, and allow resizing as the user resizes the outer browser
As you may have noticed, you can add options together, or only specify one. Try plying around with some of the options to see what exactly they do
Finally, the getWindow command loads the window containing the stage with the specified layout


SUVs could offset benefits from electric cars – report
Experts are warning that the continued popularity of SUVs could offset any benefits gained from electric cars.
In its annual World Energy Outlook, the International Energy Agency (IEA) said that if the popularity of SUVs continued to rise in line with recent trends this could add another two million barrels of oil a day to its 2040 oil demand projection.
The IEA said that in a scenario based on countries’ stated intentions, targets and existing measures, the rises in greenhouse gases slow but do not peak before 2040.
But a scenario which delivers sharp emissions cuts and meets the goals of curbing rising temperatures would need rapid and widespread changes across all parts of the energy system, the report added.
If the popularity of SUVs continues to rise in line with recent trends, this could add another two million barrels per day to our projection for 2040 oil demand
Under this sustainable development scenario, electricity would overtake oil by 2040 as the leading source of energy, as electric vehicles take off, and most of the increase would come from wind and solar power.
But the report warns that the growing demand for bigger and heavier cars was already adding extra barrels to global oil consumption.
It added: “Consumer preferences for SUVs could offset the benefits from electric cars.
“The growing appetite among consumers for bigger and heavier cars (SUVs) is already adding extra barrels to global oil consumption.
“SUVs are more difficult to electrify fully, and conventional SUVs consume 25% more fuel per kilometre than medium-sized cars.
“If the popularity of SUVs continues to rise in line with recent trends, this could add another two million barrels per day to our projection for 2040 oil demand.”


Lavrov: US-Japan security alliance ‘a problem' for Russia
MOSCOW (AP) - Russia's foreign minister says the U.S.-Japan security alliance poses "a problem" for Russia-Japan relations and complicates peace treaty talks.
The two countries have been struggling to negotiate a peace treaty after World War II because of a territorial dispute. The Soviet Union took the four southernmost Kuril Islands during the final days of the war, which Japan asserts territorial rights to.
Russian Foreign Minister Sergey Lavrov said Saturday that Japan's "military alliance with Washington, of course, is a problem" when it comes to changing the nature of the country's relationship with Russia.
Lavrov said the Japanese government promised to address Russia's concerns.
He added that implementation of the 1956 Soviet-Japanese Declaration, which outlined conditions for a peace treaty, was not possible with the U.S. military presence in Japan.
Copyright 2019 The Associated Press. All rights reserved. This material may not be published, broadcast, rewritten or redistributed.


[viewBag] title = "Link" url = "/whats-on/link" layout = "default" hidden = "0" navigation_hidden = "0" seo_description = "Link is our club for teenagers at Crockenhill Baptist Church" robot_index = "index" robot_follow = "follow" ==
Link is for teenagers. Games and activities are organised, but there is also the opportunity to sit and chill out and enjoy what's on offer at the tuck shop. Thought provoking talks are given from the Bible.
All activities at the church are carried out in accordance with our Child Protection Policy and our our Positive Behaviour Policy.


Tantei | 探偵
Home
(current)
Try again
News classification using ML
Type text news
Predict
Great, the news is real.
Be careful, this news turned out to be false. Check your sources.


Raza Akhtar
Unafffiliated
I am currently self employed as the CEO of Concordia Consulting providing IT consulting services. I am also the CEO of The Wander an adventure tour operator company.
MS Financial Engineering 2020 World Quant University Managing Professional Services 2007 Harvard Business School M.B.A 1997 Northwood University, MI B.E.E (Electrical Engineering) 1994 N.E.D University of Engineering and Technology
80302
I have presented on behalf of the Boulder-Nablus sister city project and raised charity for our local fire department. When talking to people about the causes I care about, I always try to be empathetic. I do not have experience in advocacy, however, I always try to look at the facts regardless of politics and how a cause may affect the society in the long term.
ACTBLUE WARREN FOR PRESIDENT
BOARD MEMBER FOR BOULDER NABLUS SISTER CITY PROJECT COLORADO MOUNTAIN CLUB BOULDER SHELTER SUGARLOAF FIRE DEPARTMENT
I believe that gerrymandering is probably the greatest threat to democracy. It allows for districts that represent political interests instead of communities and leads to representation which serves politics and is unable to evolve with the needs to the communities.
Over the course my career in consulting, I have worked with many organizations and have extensive experience in seeking consensus by seeking common ground and a fact based approach. I believe that reaching an impartial agreement does require us to be fair to all sides. I also think that fair redistricting will help the people and not the politics and that by focusing on the facts we can reach consensus.
I have a bachelors in engineering an MBA and a Masters in Financial Engineering. I have worked with numbers and analysis all my life so I am very comfortable with statistics and analytics. My career in consulting frequently involved helping clients reach agreement across a diverse set of competing needs and I always considered their needs and helped them reach a decision through logic and reasoning. I think that it is easier to reach an agreement if the competing needs are understood and resolved through logic, keeping the end goal in mind, which in this case would be fair and impartial redistricting.


School support staff want 'fair' deal
Last week school support staff across the country held a week of action to express frustrations over the stalling of collective agreement and pay equity negotiations.
Dozens of Ashburton College staff and support staff signed an open to local MP Andrew Falloon asking him for help in putting pressure on the government to give more job security and a better wage to school support staff.
Mr Falloon was out of the district and at a sitting of Parliament, but the letter was delivered to his Ashburton office by Ashburton College teacher aide Cezarne Rodgers and accepted by electorate secretary Alison Driscoll.
Ms Rodgers said some 95 per cent of school support staff were paid less than the living wage of $21.15, while 12 per cent were on the minimum wage of $17.70.
"The hours we work can be as little as 15 hours per week up to 25 hours and a number of support staff are on term to term, or year to year contracts, which means a lot of uncertainty and often means some have to hold down more than one job.''
Support staff included teacher aides, administration staff, librarians, Maori language assistants and technicians, she said.
Ms Rodgers, who has been a teacher aide for 15 years, said support staff were not centrally funded by government, unlike teachers.
"Our salaries come out of school operational budgets, so we compete against maintenance costs, power and so on.
"Any small wage increases we receive come from the same school pot which does not get any bigger.''
Ms Rodgers said the feeling from support staff was that ``enough was enough'' and that it was time for the government to set up and administer a central fund to pay support staff.
The same sentiment is echoed by Netherby School teacher aide Ally Greer.
Netherby School staff and pupils dressed in black and white and wrote catchy slogans on Monday to support the Fair's Fair campaign.
Mrs Greer said school support staff did their jobs "for the love of it and not for the money'', but, at the same time, they should be paid "what they deserved''.
"Like everyone else, we still need to pay our bills and we need certainty over the hours we work.''
After four years in her role, she was taking a different path, but was staying in the business of education because she was passionate about it.
Union NZEI Te Riu Roa has been negotiating collective agreements with the Ministry of Education since July 30 and pay equity processes for teacher aides have been ongoing for the past three years.


Friday, September 5, 2003
I would classify my style of communication as "get to conflict sooner rather than later." A radio DJ once classified engineering abilities as a series of personality flaws that are accidentally useful in today's IT industry and, arguably, he's right. For most folks that have to work with me, it's generally hard at first, but eventually you either love me or hate me (and I continuously work to tip that percentage towards the former : ).
However, it's the rare individual that can see past someone's personal communications style and still pull out the value. Alan Cooper is one such person. I was reading one of his books and was so lost that I called and blamed him and his parents. He straightened me out by letting politely me know that he book wasn't even trying to solve my problems and therefore it's not surprising that it didn't. Further, he ended his email like this:
"PS.  That's why they are good and I want you to keep making them. If I growl at you, well, that's my problem. Not yours."
I don't know if other people would appreciate Alan encouraging my behavior, but it's still cool to know that such tolerance exists in the world. : )


Class Parameters
java.lang.Object
com.es.unex.practica_sistemas_inteligentes.Parameters
public class Parameters
extends java.lang.Object
This class contains the initial parameters read from the configuration file,
the parameters will be used throughout the program and are enclosed here for easy reading.
Since they must not change during the execution of the program, access to the properties is allowed in read-only mode.
- Version:
- 0.1
- Author:
- eliapacioni
-
Field Summary
Fields Modifier and Type Field Description private Accident[]
accidents
Geographical incidentsprivate boolean
alSel
Selection algorithm false: RouletteWheel true: Tournamentprivate int
avgCostAntennas
Average cost of antennas * nMaxAntenna It is used to calculate the goodness of the price in fitnessprivate boolean
colors
Color management in the terminal: true: activate colors, false: deactivate For the final printing of the individual is always activeprivate CoverageArea[]
coverageAreas
Areas to be coveredprivate int
elitism
Number of elitist (can be between 0 and population size)private int
gridWidth
Grid size (the grid is always square)private int
iter
Maximum number of iterationsprivate Antenna[]
modAntennas
Available antenna modelsprivate int
nMaxAntenna
Maximum number of antennas for an individualprivate boolean
opCrossover
Crossover operator false: crossoverMulti (2 points) true: crossover (1 point)private boolean
opMutation
Mutation operator false: mutate(Antennas[]), mutate an antenna true: mutate() , changes the positionprivate float
pCrossover
Crossover Probilityprivate float
pMutation
Probability of mutationprivate int
popSize
Population sizeprivate boolean
replacement
Type of replacement chosen, stationary or generational false: Stationary true: Generationalprivate int
weightingAreas
Importance of area coverage in the algorithmprivate int
weightingConnection
Importance of connection between areasprivate int
weightingCost
Importance of keeping the cost of antennas low in the algorithm -
Constructor Summary
Constructors Constructor Description Parameters()
Manufacturer without parameters, instantiates the class with default values -
Method Summary
Modifier and Type Method Description Accident[]
getAccidents()
int
getAvgCostAntennas()
CoverageArea[]
getCoverageArea()
int
getElitism()
int
getIter()
Antenna[]
getModAntennas()
int
getnMaxAntennas()
float
getpCrossover()
float
getpMutation()
int
getPopSize()
int
getWeightingAreas()
int
getWeightingConnection()
int
getWeightingCost()
int
gridWidth()
void
implementParameters(java.io.File config)
boolean
isAlSel()
boolean
isColors()
boolean
isOpCrossover()
boolean
isOpMutation()
boolean
isReplacement()
-
Field Details
-
popSize
private int popSizePopulation size -
iter
private int iterMaximum number of iterations -
pCrossover
private float pCrossoverCrossover Probility -
pMutation
private float pMutationProbability of mutation -
elitism
private int elitismNumber of elitist (can be between 0 and population size) -
replacement
private boolean replacementType of replacement chosen, stationary or generational false: Stationary true: Generational -
opCrossover
private boolean opCrossoverCrossover operator false: crossoverMulti (2 points) true: crossover (1 point) -
opMutation
private boolean opMutationMutation operator false: mutate(Antennas[]), mutate an antenna true: mutate() , changes the position -
alSel
private boolean alSelSelection algorithm false: RouletteWheel true: Tournament -
nMaxAntenna
private int nMaxAntennaMaximum number of antennas for an individual -
avgCostAntennas
private int avgCostAntennasAverage cost of antennas * nMaxAntenna It is used to calculate the goodness of the price in fitness -
gridWidth
private int gridWidthGrid size (the grid is always square) -
coverageAreas
Areas to be covered -
accidents
Geographical incidents -
modAntennas
Available antenna models -
colors
private boolean colorsColor management in the terminal: true: activate colors, false: deactivate For the final printing of the individual is always active -
weightingAreas
private int weightingAreasImportance of area coverage in the algorithm -
weightingCost
private int weightingCostImportance of keeping the cost of antennas low in the algorithm -
weightingConnection
private int weightingConnectionImportance of connection between areas
-
-
Constructor Details
-
Parameters
public Parameters()Manufacturer without parameters, instantiates the class with default values
-
-
Method Details
-
implementParameters
public void implementParameters(java.io.File config)- Parameters:
config
- file from which to read the configuration parameters Reads the configuration parameters and stores them in the appropriate properties.
-
getPopSize
public int getPopSize()- Returns:
- int population size
-
getIter
public int getIter()- Returns:
- int maximum number of iterations
-
getpCrossover
public float getpCrossover()- Returns:
- float probability of crossover
-
getpMutation
public float getpMutation()- Returns:
- float probability of mutation
-
getElitism
public int getElitism()- Returns:
- int number of elitist
-
isReplacement
public boolean isReplacement()- Returns:
- boolean chosen replacement strategy
-
isOpCrossover
public boolean isOpCrossover()- Returns:
- boolean selected crossover operator
-
isOpMutation
public boolean isOpMutation()- Returns:
- boolean selected mutation operator
-
isAlSel
public boolean isAlSel()- Returns:
- boolean selected operator
-
getnMaxAntennas
public int getnMaxAntennas()- Returns:
- int maximum number of antennas that can be placed for an individual
-
getModAntennas
- Returns:
- Antenna[] models of available antennas
-
gridWidth
public int gridWidth()- Returns:
- int side size of the square
-
getCoverageArea
- Returns:
- CoverageAreas[] coverage areas
-
getAccidents
- Returns:
- Accident[] accidents
-
getAvgCostAntennas
public int getAvgCostAntennas()- Returns:
- the average cost of antennas
-
isColors
public boolean isColors()- Returns:
- is used to manage the colours in the terminal
-
getWeightingAreas
public int getWeightingAreas()- Returns:
- weigthing of areas coverage
-
getWeightingCost
public int getWeightingCost()- Returns:
- weigthing of antennas cost
-
getWeightingConnection
public int getWeightingConnection()- Returns:
- weigthing of areas connection
-


For the pie, heat a casserole or a large ovenproof pan over a high heat and add the oil. Once hot, add the steak pieces in batches and fry for 3-4 minutes, or until golden-brown on all sides, stirring regularly. Remove the cooked steak from the dish, transfer to a warm plate and set aside. Repeat the process with the remaining steak pieces, then set aside.
Add the onion, mushrooms, whole shallots and carrots to the emptied casserole and fry for 2-3 minutes, or until just softened.
Add the thyme, bay leaves and tomato purée and stir well to combine.
Add the ale and stir well, scraping any sediment up from the bottom of the casserole using a wooden spoon.
Return the browned steak pieces to the casserole, add the hot stock, stir well and bring the mixture to the boil. Turn down the heat, place a lid on the casserole and cook for 1½ hours, or until the beef is tender and the gravy has thickened.
Once cooked, remove the pie filling from the dish and set aside to cool.
Preheat the oven to 220C/425F/Gas 7.
Place the beef and gravy mixture in a 23cm diameter round ovenproof dish.
Roll out the pastry to 1cm/⅓in thickness and cut the pastry into a circle slightly bigger than the pie dish.
Brush a little water around the rim of the pie dish, then place the pastry over the filling and press the edges to seal the pastry to the dish.
Brush the pie with a little beaten egg, then place the pie in the oven and cook for 20-30 minutes, or until the pastry is pale golden-brown and has risen.
For the mushy peas, in a large bowl soak the peas in three times their volume of water and the bicarbonate of soda. Leave for at least four hours or, if you have the time, overnight.
Drain the peas, rinse under the tap, and place on the stove in a large pan and cover with water. Cover and bring to the boil. Once boiled, reduce the heat and simmer the peas for 1½-2 hours, stirring from time to time.
The peas should be soft and mushy in texture but not too dry. If they are wet, continue cooking over the heat with the lid off to dry out a little. Beat in the butter and season to taste with salt.
To serve, cut a slice of pie and place it on a plate and spoon some mushy peas on the side.


Learn about GFW Fires, a tool to monitor emerging fires, identify potential causes, and analyze impacts of fires on forests and people.
Learn about GFW Fires, a tool to monitor emerging fires, identify potential causes, and analyze impacts of fires on forests and people.
Learn more about the GFW Commodities, a tool to address deforestation in commodity supply chains.
Read through answers to the most frequently asked questions about GFW.


{% load static %}
.The faculty of Computers and Informatics SCU was founded in 1995
according to Supreme Universities Council decree in its session no. (342)
It was founded
under the name "the faculty of Information Sciences SCU". That name was later changed to
"the faculty of Computers and Informatics SCU" according to the Supreme Universities Council
decree no. (343). The faculty started welcoming tech-enthusiasts in April 1997, and the
actual academic study started in September 1997
.The faculty witnessed the graduation of
the first generation in 2001
The faculty of Computers and Informatics SCU is committed to
graduating individuals of high academic value to satisfy the needs of the marketplace
The faculty also seeks to prepare individuals who are capable of competing under the name of
the faculty while committing to the ethical charter of the field
.The faculty of Computers and Informatics SCU aims to be a distinguished academic institution for research and innovation by offering outstanding technical service for both the national and regional societies


Control Text
Title: My Title Goes Here
Andrew->China: Says Hello
Note right of China: China thinks\nabout it
China-->Andrew: How are you?
Note over Andrew,China: Note over Andrew,China
Andrew->>China: I am good thanks!
|
This should be a diagram! If you don't see it you need Javascript enabled | Earle West,<PHONE_NUMBER><EMAIL_ADDRESS>js sequence diagrams 2.0.1 (c) 2012-2017 Andrew Brampton (bramp.net) @license Simplified BSD license. used by permission |


boost::process::posix_status — Status returned by a finalized child process on a POSIX system.
class posix_status : public boost::process::status { public: // construct/copy/destruct posix_status(const status &); // public member functions bool signaled(void) const; int term_signal(void) const; bool dumped_core(void) const; bool stopped(void) const; int stop_signal(void) const; };
This class represents the status returned by a child process after it has terminated. It contains some methods not available in the status class that provide information only available in POSIX systems.
posix_status
construct/copy/destructposix_status(const status & s);
Creates a new status object representing the exit status of a child process. The construction is done based on an existing status object which already contains all the available information: this class only provides controlled access to it.
posix_status
public member functionsbool signaled(void ) const;
Returns whether the process exited due to an external signal. The result is always false in Win32 systems.
int term_signal(void ) const;
If the process was signaled, returns the terminating signal code. Cannnot be called under Win32 because the preconditions will not ever be met.
| Requires: | signaled() is true. |
bool dumped_core(void ) const;
If the process was signaled, returns whether the process produced a core dump. Cannnot be called under Win32 because the preconditions will not ever be met.
| Requires: | signaled() is true. |
bool stopped(void ) const;
Returns whether the process was stopped by an external signal. The result is always false in Win32 systems.
int stop_signal(void ) const;
If the process was stopped, returns the stop signal code. Cannnot be called under Win32 because the preconditions will not ever be met.
| Requires: | signaled() is true. |
| Copyright © 2006 Julio M. Merino Vidal |


Turn on monitoring and video fragment URLs will be collected below. The list of URLs can also be manually edited.
Use the Generate button to produce a download pattern from the collected URLs. Or enter a URL pattern manually. Press Download button to download the fragments.


---
layout: post
status: publish
published: true
title: VMworld 2010 - The Future Here & Now
author:
display_name: iguy
login: iguy
email<EMAIL_ADDRESS>url: ''
author_login: iguy
author_email<EMAIL_ADDRESS>wordpress_id: 473
wordpress_url: http://itsjustanotherlayer.com/?p=473
date: !binary |-
MjAxMC0wOC0yMyAwOTozMToyNiAtMDUwMA==
date_gmt: !binary |-
MjAxMC0wOC0yMyAxNDozMToyNiAtMDUwMA==
categories:
- VMware
tags:
- future
- vmworld
comments: []
---
The year, the past.
The place, a convention in a week.
I'm prepped. I'm ready. I'm excited. I'm nervous. I've got a presentation I'm going to do. There's going to be tons of announcements and product releases. I'm working myself into a frenzy about everything that's going to happen and things I need to be ready for and and and...
Needless to say at this point I need a stiff drink. My friends know that doesn't work so they come over and we start talking. Lots of silliness in-sued and stress occurred. Something fun that came out of that stress release is a game that I like to do about the next convention I'm heading to.
Rules of the Prophecy Game:
- You get a point for each item you bring up first that happens.
- If it is NDA, can't mention it. No fair to the game as you already know the announcement and we don't want you getting in trouble.
- If it is massively public knowledge, you can say it, you just don't get points for it coming true. (Team vote if prophecy is public knowledge already.)
- Winner at end of convention for most points gets crowned "Oracle of VMworld2010".
What do I think that will happen at VMworld 2010?
- Number of Booths with uninformed Booth Babes/Dudes will be less than VMworld2009
- Session turnout will be smaller on average than last year
- iPad is the raffle gift of choice this year (a gimme I know)
- EMC will show some incredible tech (VPLEX) that will encourage VMware to one-up it
- vD0dgeball will have a significant turnout of vSquirrels, vSpecialists and just everyone
- vSpecialists are going to win 5 out of 9 games
- Symantec will have some new product that will attempt to replace some VMware supplied tech and be rather disruptive to your environment again instead of using APIs supplied
- Citrix or Microsoft will have some marketing approach that is rather childish
- Lots of VMware announcements about the Ionix acquisition
- Twitter will hit a good 30k tweets in #vmworld
- @jTroyer will get 2 hours of sleep a night all week
- @Lynxbat will announce some cool enhancement to a virtual appliance
That being said here's my prophecies on VMware's product line and keynotes:
- Will announce general availability of VMware's first Cloud Delivery Tool (Likely called Service Director) for your own private cloud
- Announce cross datacenter vMotion & Storage vMotion capabilities
- VMware will purchase Teradici for $50mil
- Will announce VMware is getting into selling servers (everyone else is doing it why not VMware?)
- View 4.next will finally go GA
- VMware join the battle to buy 3Par
What do you think will happen at VMworld 2010?


I'm a PHP developer
I've often worked directly with non-technical product owners and users
I workED at a University
I'm a PHP developer
I've often worked directly with non-technical product owners and users
I workED at a University
Communicate with non-technical users of the product
Removes implementation from the discussion
Objective-focused deliverables
A diagram of a project that tells the story of the people and systems involved in a process.
Detail is added as we learn more about the project
The map can be built for an existing application or a new application.
Anyone who knows the process ... Not Just Developers
At least one knowledgeable person from each group of stakeholders
*Lowers problems with estimates and feature creep
A large, clear wall or whiteboard.
A place central to the team, at least in the beginning.
Use a familiar process that is not your project
List five tasks you do in order to get to work. Put each one on a post-it provided.
Pick 3 things that you did today that are different from your normal work routine.
Who are the Actors/Users in your morning routine?
If you cannot elaborate, mark it and revisit
If the only thing you create while making sense of a big opportunity is more, small stories, you're doing it wrong.
- Jeff Patton
Focus on releasing valuable features every time.
Sometimes we plan features in a chronological order
Or we divide the project into components


Full-Stack and Java Developer
I'm a full stack devleper with experience in MERN stack (MondgoDB, Express, Node, React) development, enterprise Java applications, and IOT development with the Tessel 2 board and Johnny Five library.
Recently I've built a product quote and configuration app using Spring Boot, React, and MySQL, a QA reporting app with Spring MVC, Hibernate, and MySQL, (my personal favorite) an automated garden design and irrigation application with the Mern stack, and am currently working on a Marketing CMS application using the MERN stack.
I'm a curious and hardworking developer, and love to keep pushing myself to learn new technologies. Check out some of the recent projects I've worked on, and if I might be fit for your needs, let's talk!
Full-Stack Web Developer
Full Stack Web Developer with diverse IT experience, knowledge of multiple programming languages, libraries, and frameworks, and a passion for back-end, front-end, and embedded systems development. Effective at working with my coworkers to find creative and collaborative solutions to challenging problems. Strong desire to learn, attention to detail, and persistence with projects.
Delkor Systems, MN 4/2019 - Present
Delkor Systems, MN 2017-2019
Design Ready Controls, MN 2016-2017
Delkor Systems, MN 2013-2016
Full Stack Web Development Program 2019
B.S. in Physics and Electrical Engineering 2006-2011


{% load i18n %}
Hi {{ user.get_full_name }},
Your registered email is {{ email }}, click the link below to confirm it.
{{ confirmation_url }}


Post Successfully!!!!
Post The Title Here...
Contents !
Post The Title Here...
Contents !
There is no good blog
without great readability !
Fly directly into a fireworks display with this drone footage...
How the internet is democratizing luxury...
Fly directly into a fireworks display with this drone footage...
How the internet is democratizing luxury...
Beautiful blogs are here ..............
I have an internet acquaintance that I have been following on social media for a little over two years now, an all around nice....
If travelling solo sounds terrifying, that's because you haven't realized why it can be the best way to go...


[t]Dear[/t] {$candidate_name},
[t]We have the regret to inform you that you didn’t pass the test.[/t]
[t]Regards,[/t] {$signature}


Impaired driving is punishable with a 1 year driving suspension for a first offence. However, is is possible to negotiate with the prosecutor and get back on the road in as little as 3 months.
To be eligible for the shortened suspension you have to offer to get an ignition interlock device temporally installed in your car. An ignition interlock is a machine that won't let yout start your car until you pass a breath alcohol test. The device must stay on your car for between 6 to 9 months. It costs about $ 200 for installation, $ 150 a month for monitoring and $ 70 to get it removed.
How much your suspension can be shortened with a device is determined by the specific circumstances of your case. To be eligible for a 3 month suspension, you must plead guilty within 90 days of the offence date.


0
0
Epic Background Music
Press SpaceBar to start
Epic Rainbow Path
Exit
1 Player Mode
2 Player Mode
Level 1
Level 2
Level 3
W
S
↑
↓
Got it!
Check Nyan Pong out on GitHub


Reports
Scrollable
components, except for
JTextField
, which are not placed in a
JScrollPane
. The quickfix surrounds the problematic component with a scroll pane.


Gradient Projection Algorithm Rotation for Factor Analysis. See ?GPArotation.Intro for more details.
| Version: | 2014.11-1 |
| Depends: | R (≥ 2.0.0) |
| Published: | 2014-11-25 |
| Author: | Coen Bernaards and Robert Jennrich |
| Maintainer: | Paul Gilbert <pgilbert.ttv9z at ncf.ca> |
| License: | GPL-2 | GPL-3 | file LICENSE [expanded from: GPL (≥ 2) | file LICENSE] |
| URL: | http://www.stat.ucla.edu/research/gpa |
| NeedsCompilation: | no |
| Citation: | GPArotation citation info |
| Materials: | NEWS |
| In views: | Multivariate, Psychometrics |
| CRAN checks: | GPArotation results |
| Reference manual: | GPArotation.pdf |
| Vignettes: |
gpa Guide |
| Package source: | GPArotation_2014.11-1.tar.gz |
| Windows binaries: | r-devel: GPArotation_2014.11-1.zip, r-release: GPArotation_2014.11-1.zip, r-oldrel: GPArotation_2014.11-1.zip |
| OS X binaries: | r-release: GPArotation_2014.11-1.tgz, r-oldrel: GPArotation_2014.11-1.tgz |
| Old sources: | GPArotation archive |
| Reverse depends: | DeducerPlugInScaling, EMMAgeo, PCovR, tsfa |
| Reverse imports: | Compind, DCA, EFAutilities, fungible, jmv, mirt, OpenRepGrid, qmethod, radiant.multivariate, traj, userfriendlyscience |
| Reverse suggests: | Lambda4, psych, psycho, REdaS, semTools, sjPlot, TAM |
Please use the canonical form https://CRAN.R-project.org/package=GPArotation to link to this page.


beach hut
If you need help planning a web project or have one ready to go why not reach out. We can help.
- tim on 01 5045638
-<EMAIL_ADDRESS>What we can do for you:
Here's a list of just some of the things we can do
Web design
We provide Creative and functional design for the web. We build all our websites using HTML,CSS, Javascript while adhering to best practice. Brochure sites, e-commerce sites, membership sites, blogs, payments gateways ..the list goes on.
Website Redesign
The web is a fast evolving extremely competitive environment. A well designed site that looks good on all screens will distinguish you from the majority of the web. Studies show users don't trust badly designed Websites.
E-Commerce
Every year people spend more and more money on line and with a new generation of shoppers who are now more comfortable than ever buying online your companies e-commerce stratgey must be right.
responsive web design
Websites that look great accross all devices, desktops, laptops, mobiles and tablets. Its expected that up to 50% of internet traffic will be accessed through mobile devices this year 2016.
Content Management Systems
Wordpress is our preferred open source cms because its simple to use and reliable. But we're not limited to any technology, we also like Perch and can even custom build you a cms with Ruby on Rails if required.
SEO & Analytics
All our site are built to adhere to SEO best practice giving you the greatest chance of positioning high in search engine results. Analytics are now essential to online success. Our websites are set up for google analytics giving you insights into its performance on a daily basis.
E-mail marketing
One the oldest and most effective methods of marketing to new and existing customers. We can build e-mail templates that work and then manage campaigns for you.
Support & Training
We'll make sure you know the in's an out's of your new website or application with support and training.
More
If you've got addtional requirements that your project needs, try us, we love to research new technological solutions to customers problems. Not everything has to be built from scratch and there are many ready made solutions now on the market that you may not be aware of.


|
Firmware BRDQBRQBC = HFW2 documentation - qbcontrol main board
Centro E.Piaggio
|
Definition of utility functions. More...
#include <globals.h>
Go to the source code of this file.
Macros | |
| #define | SIGN(A) (((A) > 0) ? (1) : ((((A) < 0) ? (-1) : (0)))) |
Definition of utility functions.
Declaration of utility functions.


BMA takes NHS property company to court over ‘unlawful’ fees
by Nick Carding- NHS Property Services facing legal action from doctors’ union
- British Medical Association says GPs are given “unjustifiable” estates fees
- GPs owe NHS Property Services more than £170m in rent
The British Medical Association will take the much-maligned NHS property company to court over fees charged which the union describes as “unjustifiable”.
According to the BMA, GPs leasing buildings from NHS Property Services have seen their charges rise – sometimes double – despite no formal agreement being made between the parties.
The union also said some practices have been billed for services they are not receiving, such as a surgery being billed for a lift that didn’t exist and others for payments that have already been made to the local authority.
It hopes its court action will provide a “template” for GP practices to defend “unlawful” claims for service charges by NHS PS.
NHS PS said it could not comment due to purdah, and referred HSJ’s request for a response to the Department of Health and Social Care.
The dispute between GPs and NHS PS has existed since the property company was set up in 2013 to manage estate formerly owned by primary care trusts.
NHS PS has only agreed leases with one third of its tenants, and many GPs dispute the bills they are sent by the company. A report by the National Audit Office this summer revealed GPs owe NHS PS £173m in back-rent. This amounts to around 30 per cent of NHS PS’ debt, even though GPs only use 18 per cent of the company’s estate.
However, NHS PS does not have the same powers as a commercial landlord – such as being able to evict tenants or take legal action – which has contributed to the company running a deficit every year.
Earlier this month the Public Accounts Committee said the “whole system needs to work together far more effectively to find a solution” and claimed the company had been “set up to fail”.
But the BMA claims many GPs are not given a “clear breakdown” of what their charges relate to.
The union’s chair of its GP committee Richard Vautrey will tell a conference today: “It’s not acceptable that practices in NHS PS premises are left to pick up the cost of an unjustifiable hike in charges.
“We will stand up for GPs and take legal action when it’s necessary to defend our profession.”
HSJ Strategic Estates Forum
The HSJ Strategic Estates Forum, now in its 3rd year, takes place in London on 12 March 2020. This is a high level strategic forum that brings together estates directors, sustainability and transformation partnership estates leads and trust board leaders responsible for the estates function who are developing strategic plans for their organisations and local health economies. The focus of the forum is on issues such as availability of and access to capital, tackling backlog maintenance, utilisation of the estate and role of technology in infrastructure development. The forum builds on the Naylor Report and highly anticipated 2019 spending review.


Recombination is an important evolutionary mechanism responsible for the genetic diversity in humans and other organisms. Recently, there has been extensive research on understanding the fine scale variation in recombination rates across the human genome using DNA polymorphism data. A combinatorial approach toward this is to estimate the minimum number of recombination events in any history of the sample. During 2003-2007, I developed several recombination lower bounds on this minimum number of recombination events. We also explored the computational complexity of these lower bounds. The publications that describe this work are listed below:
Vineet Bafna,
Vikas Bansal:
The Number of Recombination Events in a Sample History: Conflict Graph and Lower Bounds.
IEEE/ACM Trans. Comput. Biology Bioinform. 1(2): 78-90 (2004)
Vineet Bafna,
Vikas Bansal:
Improved Recombination Lower Bounds for Haplotype Data.
RECOMB 2005: 569-584
Vineet Bafna,
Vikas Bansal:
Inference about Recombination from Haplotype Data: Lower Bounds and Recombination Hotspots.
Journal of Computational Biology 13(2): 501-521 (2006)
Dan Gusfield,
Vikas Bansal,
Vineet Bafna,
Yun S. Song:
A Decomposition Theory for Phylogenetic Networks and Incompatible Characters.
Journal of Computational Biology 14(10): 1247-1272 (2007)
The program LUBOUND that calculates the lower bound R_I and the PDFs of several papers describing these lower bounds can be downloaded from the attachments.