text:
Accueil > Informations > événements scientifiques
Colloque international "Location and Dislocation of Myth in the Colonial and Postcolonial Anglophone World"
Location and Dislocation of Myth in the Colonial and Postcolonial Anglophone World
Université Stendhal Grenoble 3
9-10-11 avril 2014
The research group on Modes of Representation in English studies, CEMRA EA 3016, from University Stendhal-Grenoble 3 is pleased to announce the organisation of an international conference on "Location and dislocation of myth in the colonial and postcolonial Anglophone world" to be held at University Stendhal on April 9, 10 and 11, 2014.
Drawing on the tension between the universality of myth and its cultural and territorial location, this conference proposes to examine the role played by antagonism, protest, insurrection, rebellion, conflict and war in the history of the English-speaking countries that have gone through both colonial and postcolonial experiences leading to forced migration, diaspora, displacement and exile. Be they the imperial, metropolitan centre or the resisting, local margin, territories are represented in tight connection with their supposed archaic origins. They have also often been defined by battles that were either lost or won by conquerors and gave rise to myths that aimed at strengthening identity and giving a purpose to an entire nation, even in the critical context of globalization. Alongside Mircea Eliades' and Northrop Frye's work, myths can be understood as narratives that best reflect the human endeavour to place oneself in the world and explain one's nature and destiny in a bigger universe. Myth also creates and names territories, aiming to cement a community, a nation, and to hold the colony or country together.
Territories come in different forms and sizes, ranging from the distant and geographically isolated island to the apparently boundless territories of Canada, India or Australia. Focusing on the dynamics of mythic territories, through the examples of specific types of space (the island, the frontier territory, the metropolis), the conference will also survey the centrifugal and centripetal movements induced by the myths of inclusion or exclusion. Not only do national myths define territories, but they shape them into imaginary spaces and discourses involving resistance against the conquerors who wished to mould the colony into a mere replica of the homeland, thereby stripping its culture of its unique nature and language. As a result, social, ideological, political, philosophical and artistic conflicts have originated from the clash between those who are included in the national myth and those who are excluded from it. The crucial concept of the border that exists only to separate and therefore define territory can be the material representation of the mental divide that brings entire communities into conflict and ultimately to war.
We will welcome papers dealing with the historical, political and ideological uses of myth in specific territories (such as the 1857 Rebellion in India, the Morant Bay Rebellion in Jamaica, or Bloody Sunday in Ireland), or about the ability of myth to recreate and rewrite history in grand narratives. The issue of myth and territory is of course relevant in the field of literature, raising questions about the nationness (Homi K. Bhabha, The Location of Culture) of a text, its contribution to a cultural and mythic framework, or its power to reshape territorial representations. Papers dealing with all visual arts, including cinema and television, are also welcome, in so far as they address the modes of illustration of territories and myths and the impact of artistic representations of national myth on the general public. The angles suggested here are, of course, non-exhaustive. Hopefully, as a result of this conference, we will see more clearly into the liminal moments that have given shape to a nation or changed it altogether.
Aucun document joint


text:
package com.arjuna.wst11.messaging.engines;

import com.arjuna.webservices.SoapFault;
import com.arjuna.webservices.logging.WSTLogger;
import com.arjuna.webservices.util.TransportTimer;
import com.arjuna.webservices11.wsaddr.AddressingHelper;
import com.arjuna.wst11.ConfirmCompletedParticipant;
import org.jboss.ws.api.addressing.MAP;
import com.arjuna.webservices11.wsarj.ArjunaContext;
import com.arjuna.webservices11.wsarj.InstanceIdentifier;
import com.arjuna.webservices11.wsba.ParticipantCompletionParticipantInboundEvents;
import com.arjuna.webservices11.wsba.State;
import com.arjuna.webservices11.wsba.BusinessActivityConstants;
import com.arjuna.webservices11.wsba.client.ParticipantCompletionCoordinatorClient;
import com.arjuna.webservices11.wsba.processors.ParticipantCompletionParticipantProcessor;
import com.arjuna.webservices11.wscoor.CoordinationConstants;
import com.arjuna.wsc11.messaging.MessageId;
import com.arjuna.wst.BusinessAgreementWithParticipantCompletionParticipant;
import com.arjuna.wst.FaultedException;
import org.oasis_open.docs.ws_tx.wsba._2006._06.NotificationType;
import org.oasis_open.docs.ws_tx.wsba._2006._06.StatusType;
import org.jboss.jbossts.xts11.recovery.participant.ba.BAParticipantRecoveryRecord;
import org.jboss.jbossts.xts.recovery.participant.ba.XTSBARecoveryManager;

import javax.xml.namespace.QName;
import javax.xml.ws.wsaddressing.W3CEndpointReference;
import java.util.TimerTask;

/**
 * The participant completion participant state engine
 * @author kevin
 */
public class ParticipantCompletionParticipantEngine implements ParticipantCompletionParticipantInboundEvents
{
    /**
     * The participant id.
     */
    private final String id ;
    /**
     * The instance identifier.
     */
    private final InstanceIdentifier instanceIdentifier ;
    /**
     * The coordinator endpoint reference.
     */
    private final W3CEndpointReference coordinator ;
    /**
     * The associated participant
     */
    private final BusinessAgreementWithParticipantCompletionParticipant participant ;
    /**
     * The current state.
     */
    private State state ;
    /**
     * The associated timer task or null.
     */
    private TimerTask timerTask ;

    /**
     * the time which will elapse before the next message resend. this is incrementally increased
     * until it reaches RESEND_PERIOD_MAX
     */
    private long resendPeriod;

    /**
     * the initial period we will allow between resends.
     */
    private long initialResendPeriod;

    /**
     * the maximum period we will allow between resends. n.b. the coordinator uses the value returned
     * by getTransportTimeout as the limit for how long it waits for a response. however, we can still
     * employ a max resend period in excess of this value. if a message comes in after the coordinator
     * has given up it will catch it on the next retry.
     */
    private long maxResendPeriod;

    /**
     * the amount of time we will wait for a response to a dispatched message
     */
    private long timeout;

    /**
     * true if this participant has been recovered otherwise false
     */
    private boolean recovered;

    /**
     * true if this participant's recovery details have been logged to disk otherwise false
     */
    private boolean persisted;

    /**
     * true if the participant should send getstatus rather than resend a completed message
     */
    private boolean checkStatus;

    /**
     * Construct the initial engine for the participant.
     * @param id The participant id.
     * @param coordinator The coordinator endpoint reference.
     * @param participant The participant.
     */
    public ParticipantCompletionParticipantEngine(final String id, final W3CEndpointReference coordinator,
        final BusinessAgreementWithParticipantCompletionParticipant participant)
    {
        this(id, coordinator, participant, State.STATE_ACTIVE, false) ;
    }

    /**
     * Construct the engine for the participant in a specified state.
     * @param id The participant id.
     * @param coordinator The coordinator endpoint reference.
     * @param participant The participant.
     * @param state The initial state.
     * @param recovered true if the engine has been recovered from th elog otherwise false
     */
    public ParticipantCompletionParticipantEngine(final String id, final W3CEndpointReference coordinator,
        final BusinessAgreementWithParticipantCompletionParticipant participant, final State state, boolean recovered)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + " constructor. Id: " + id + ", coordinator"
                    + coordinator + ", participant: " + participant + " state: " + state + ", recovered: " + recovered);
        }

        this.id = id ;
        this.instanceIdentifier = new InstanceIdentifier(id) ;
        this.coordinator = coordinator ;
        this.participant = participant ;
        this.state = state ;
        this.recovered = recovered;
        this.persisted = recovered;
        this.initialResendPeriod = TransportTimer.getTransportPeriod();
        this.maxResendPeriod = TransportTimer.getMaximumTransportPeriod();
        this.timeout = TransportTimer.getTransportTimeout();
        this.resendPeriod = initialResendPeriod;
        // we always check the status of a recovered participant and we always start off sending completed
        // if the participant is not recovered
        this.checkStatus = recovered;
    }

    /**
     * Handle the cancel event.
     * @param cancel The cancel notification.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     *
     * Active -> Canceling
     * Canceling -> Canceling
     * Completed -> Completed (resend Completed)
     * Closing -> Closing
     * Compensating -> Compensating
     * Failing-Active -> Failing-Active (resend Fail)
     * Failing-Canceling -> Failing-Canceling (resend Fail)
     * Failing-Compensating -> Failing-Compensating
     * NotCompleting -> NotCompleting (resend CannotComplete)
     * Exiting -> Exiting (resend Exit)
     * Ended -> Ended (resend Cancelled)
     */
    public void cancel(final NotificationType cancel, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".cancel");
        }

        final State current ;
        synchronized(this)
        {
            current = state ;
            if (current == State.STATE_ACTIVE)
            {
                changeState(State.STATE_CANCELING) ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".cancel. State: " + current);
        }

        if (current == State.STATE_ACTIVE)
        {
            executeCancel() ;
        }
        else if (current == State.STATE_COMPLETED)
        {
            sendCompleted() ;
        }
        else if ((current == State.STATE_FAILING_ACTIVE) || (current == State.STATE_FAILING_CANCELING))
        {
            sendFail(current.getValue()) ;
        }
        else if (current == State.STATE_NOT_COMPLETING)
        {
            sendCannotComplete() ;
        }
        else if (current == State.STATE_EXITING)
        {
            sendExit() ;
        }
        else if (current == State.STATE_ENDED)
        {
            sendCancelled() ;
        }
    }

    /**
     * Handle the close event.
     * @param close The close notification.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     *
     * Active -> Active (invalid state)
     * Canceling -> Canceling (invalid state)
     * Completed -> Closing
     * Closing -> Closing
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (invalid state)
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended (send Closed)
     */
    public void close(final NotificationType close, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".close");
        }

        final State current ;
        synchronized(this)
        {
            current = state ;
            if (current == State.STATE_COMPLETED)
            {
                changeState(State.STATE_CLOSING) ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".close. State: " + current);
        }

        if (current == State.STATE_COMPLETED)
        {
            if (timerTask != null)
            {
                timerTask.cancel() ;
            }
            executeClose() ;
        }
        else if (current == State.STATE_ENDED)
        {
            sendClosed() ;
        }
    }

    /**
     * Handle the compensate event.
     * @param compensate The compensate notification.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     *
     * Active -> Active (invalid state)
     * Canceling -> Canceling (invalid state)
     * Completed -> Compensating
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (resend Fail)
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended (send Compensated)
     */
    public void compensate(final NotificationType compensate, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".compensate");
        }

        final State current ;
        synchronized(this)
        {
            current = state ;
            if (current == State.STATE_COMPLETED)
            {
                changeState(State.STATE_COMPENSATING) ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".compensate. State: " + current);
        }

        if (current == State.STATE_COMPLETED)
        {
            if (timerTask != null)
            {
                timerTask.cancel() ;
            }
            executeCompensate() ;
        }
        else if (current == State.STATE_FAILING_COMPENSATING)
        {
            sendFail(current.getValue()) ;
        }
        else if (current == State.STATE_ENDED)
        {
            sendCompensated() ;
        }
    }

    /**
     * Handle the exited event.
     * @param exited The exited notification.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     *
     * Active -> Active (invalid state)
     * Canceling -> Canceling (invalid state)
     * Completed -> Completed (invalid state)
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (invalid state)
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Ended
     * Ended -> Ended
     */
    public void exited(final NotificationType exited, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".exited");
        }

        final State current ;
        synchronized(this)
        {
            current = state ;
            if (current == State.STATE_EXITING)
            {
                ended() ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".exited. State: " + current);
        }
    }

    /**
     * Handle the failed event.
     * @param failed The failed notification.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     *
     * Active -> Active (invalid state)
     * Canceling -> Canceling (invalid state)
     * Completed -> Completed (invalid state)
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Ended
     * Failing-Canceling -> Ended
     * Failing-Compensating -> Ended
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended
     */
    public void failed(final NotificationType failed,  final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".failed");
        }

        final State current ;
        boolean deleteRequired = false;
        synchronized(this)
        {
            current = state ;
            if ((current == State.STATE_FAILING_ACTIVE) || (current == State.STATE_FAILING_CANCELING) ||
                (current == State.STATE_FAILING_COMPENSATING))
            {
                deleteRequired = persisted;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".failed. State: " + current);
        }

        // if we just ended the participant ensure any log record gets deleted

        if (deleteRequired) {
            if (!XTSBARecoveryManager.getRecoveryManager().deleteParticipantRecoveryRecord(id)) {
                // hmm, could not delete entry -- nothing more we can do than log a message
                WSTLogger.i18NLogger.warn_wst11_messaging_engines_ParticipantCompletionParticipantEngine_failed_1(id);
            }
        }
        // now the log record has been deleted we can safely end this participant
        if ((current == State.STATE_FAILING_ACTIVE) || (current == State.STATE_FAILING_CANCELING) ||
            (current == State.STATE_FAILING_COMPENSATING))
        {
            ended();
        }
    }

    /**
     * Handle the not completed event.
     * @param notCompleted The notCompleted notification.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     *
     * Active -> Active (invalid state)
     * Canceling -> Canceling (invalid state)
     * Completed -> Completed (invalid state)
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (invalid state)
     * NotCompleting -> Ended
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended
     */
    public void notCompleted(final NotificationType notCompleted, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".notCompleted");
        }

        final State current ;
        synchronized(this)
        {
            current = state ;
            if (current == State.STATE_NOT_COMPLETING)
            {
        	ended() ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".notCompleted. State: " + current);
        }
    }

    /**
     * Handle the getStatus event.
     * @param getStatus The getStatus notification.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     *
     */
    public void getStatus(final NotificationType getStatus, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".getStatus");
        }

	final State current ;
	synchronized(this)
	{
	    current = state ;
	}

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".getStatus. State: " + current);
        }

	sendStatus(current) ;
    }

    /**
     * Handle the status event.
     * @param status The status type.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     */
    public void status(final StatusType status, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".status");
        }

        // TODO --  check that the status is actually what we expect

        // revert to sending completed messages and reset the resend period to the initial period
        checkStatus = false;
        updateResendPeriod(false);
    }

    /**
     * Handle the recovery event.
     *
     * Active -> Active (invalid state)
     * Canceling -> Canceling (invalid state)
     * Completed -> Completed (resend completed)
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (invalid state)
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended (invalid state)
     */
    public void recovery()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".recovery");
        }

        final State current ;
        synchronized(this)
        {
            current = state ;
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".recovery. State: " + current);
        }

        if (current == State.STATE_COMPLETED)
        {
            sendCompleted(true);
        }
    }

    /**
     * Handle the soap fault event.
     * @param soapFault The soap fault.
     * @param map The addressing context.
     * @param arjunaContext The arjuna context.
     */
    public void soapFault(final SoapFault soapFault, final MAP map, final ArjunaContext arjunaContext)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".soapFault");
        }

        boolean deleteRequired;
        boolean checkingStatus;
        synchronized(this) {
            deleteRequired = persisted;
            // make sure delete is attempted only once
            persisted = false;
            checkingStatus = (state == State.STATE_COMPLETED && checkStatus);
            ended() ;
        }
        // TODO -- update doc in interface and user guide.
        try
        {
            boolean isInvalidState = soapFault.getSubcode().equals(CoordinationConstants.WSCOOR_ERROR_CODE_INVALID_STATE_QNAME);
            if (checkingStatus && isInvalidState) {
                // coordinator must have died before reaching close so just cancel
                WSTLogger.i18NLogger.warn_wst11_messaging_engines_ParticipantCompletionParticipantEngine_soapFault_2(id);
                participant.compensate();
            } else {
                // hmm, something went wrong -- notify the participant of the error
                WSTLogger.i18NLogger.warn_wst11_messaging_engines_ParticipantCompletionParticipantEngine_soapFault_3(id);
                participant.error();
            }
        }
        catch (final Throwable th) {} // ignore
        // if we just ended the participant ensure any log record gets deleted
        if (deleteRequired) {
            if (!XTSBARecoveryManager.getRecoveryManager().deleteParticipantRecoveryRecord(id)) {
                // hmm, could not delete entry -- nothing more we can do than log a message
                WSTLogger.i18NLogger.warn_wst11_messaging_engines_ParticipantCompletionParticipantEngine_soapFault_1(id);
            }
        }
    }

    /**
     * Handle the completed event.
     *
     * Active -> Completed
     * Canceling -> Canceling (invalid state)
     * Completed -> Completed
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (invalid state)
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended (invalid state)
     */
    public State completed()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".completed");
        }

        State current ;
        boolean failRequired  = false;
        boolean deleteRequired  = false;
        boolean confirm = (participant instanceof ConfirmCompletedParticipant);
        synchronized(this)
        {
            current = state ;

            // we have to do this synchronized so that we don't try writing the participant details twice

            if (current == State.STATE_ACTIVE) {
                // ok we need to write the participant details to disk because it has just completed
                BAParticipantRecoveryRecord recoveryRecord = new BAParticipantRecoveryRecord(id, participant, true, coordinator);

                if (XTSBARecoveryManager.getRecoveryManager().writeParticipantRecoveryRecord(recoveryRecord)) {
                    changeState(State.STATE_COMPLETED);
                    persisted = true;
                    // if necessary notify the client now. n.b. this has to be done synchronized because
                    // if we release the lock then a resent COMPLETE may result in a COMPLETED being
                    // sent back and we cannot allow that until after the confirm
                    if (confirm) {
                        ((ConfirmCompletedParticipant) participant).confirmCompleted(true);
                    }
                } else {
                    // hmm, could not write entry log warning
                    WSTLogger.i18NLogger.warn_wst11_messaging_engines_ParticipantCompletionParticipantEngine_completed_1(id);
                    // we need to fail this transaction
                    failRequired = true;
                }
            }
        }

        // check to see if we need to send a fail or delete the log record before going ahead to complete

        if (failRequired) {
            current = fail(BusinessActivityConstants.WSBA_ELEMENT_FAIL_QNAME);
            // we can safely do this now
            if (confirm) {
                ((ConfirmCompletedParticipant) participant).confirmCompleted(false);
            }
        } else if ((current == State.STATE_ACTIVE) || (current == State.STATE_COMPLETED)) {
            sendCompleted() ;
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".completed. State: " + current);
        }

        return current ;
    }

    /**
     * Handle the exit event.
     *
     * Active -> Exiting
     * Canceling -> Canceling (invalid state)
     * Completed -> Completed (invalid state)
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (invalid state)
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Exiting
     * Ended -> Ended (invalid state)
     */
    public State exit()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".completed");
        }

        final State current ;
        synchronized (this)
        {
            current = state ;
            if (current == State.STATE_ACTIVE)
            {
                changeState(State.STATE_EXITING) ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".completed. State: " + current);
        }

        if ((current == State.STATE_ACTIVE) || (current == State.STATE_EXITING))
        {
            sendExit() ;
        }

        return waitForState(State.STATE_EXITING, timeout) ;
    }

    /**
     * Handle the fail event.
     *
     * Active -> Failing-Active
     * Canceling -> Failing-Canceling
     * Completed -> Completed (invalid state)
     * Closing -> Closing (invalid state)
     * Compensating -> Failing-Compensating
     * Failing-Active -> Failing-Active
     * Failing-Canceling -> Failing-Canceling
     * Failing-Compensating -> Failing-Compensating
     * NotCompleting -> NotCompleting (invalid state)
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended (invalid state)
     */
    public State fail(final QName exceptionIdentifier)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".fail");
        }

        final State current ;
        synchronized (this)
        {
            current = state ;
            if (current == State.STATE_ACTIVE)
            {
                changeState(State.STATE_FAILING_ACTIVE) ;
            }
            else if (current == State.STATE_CANCELING)
            {
        	changeState(State.STATE_FAILING_CANCELING) ;
            }
            else if (current == State.STATE_COMPENSATING)
            {
                changeState(State.STATE_FAILING_COMPENSATING) ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".fail. State: " + current);
        }

        if ((current == State.STATE_ACTIVE) || (current == State.STATE_FAILING_ACTIVE))
        {
            sendFail(exceptionIdentifier) ;
            return waitForState(State.STATE_FAILING_ACTIVE, timeout) ;
        }
        else if ((current == State.STATE_CANCELING) || (current == State.STATE_FAILING_CANCELING))
        {
            sendFail(exceptionIdentifier) ;
            return waitForState(State.STATE_FAILING_CANCELING, timeout) ;
        }
        else if ((current == State.STATE_COMPENSATING) || (current == State.STATE_FAILING_COMPENSATING))
        {
            sendFail(exceptionIdentifier) ;
            return waitForState(State.STATE_FAILING_COMPENSATING, timeout) ;
        }

        return current ;
    }

    /**
     * Handle the cannot complete event.
     *
     * Active -> NotCompleting
     * Canceling -> Canceling (invalid state)
     * Completed -> Completed (invalid state)
     * Closing -> Closing (invalid state)
     * Compensating -> Compensating (invalid state)
     * Failing-Active -> Failing-Active (invalid state)
     * Failing-Canceling -> Failing-Canceling (invalid state)
     * Failing-Compensating -> Failing-Compensating (invalid state)
     * NotCompleting -> NotCompleting
     * Exiting -> Exiting (invalid state)
     * Ended -> Ended (invalid state)
     */
    public State cannotComplete()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".cannotComplete");
        }

        final State current ;
        synchronized (this)
        {
            current = state ;
            if (current == State.STATE_ACTIVE)
            {
                changeState(State.STATE_NOT_COMPLETING) ;
            }
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".cannotComplete. State: " + current);
        }

        if ((current == State.STATE_ACTIVE) || (current == State.STATE_NOT_COMPLETING))
        {
            sendCannotComplete() ;
            return waitForState(State.STATE_NOT_COMPLETING, timeout) ;
        }
        return current ;
    }

    /**
     * Handle the comms timeout event.
     *
     * Completed -> Completed (resend Completed)
     */
    private void commsTimeout(TimerTask caller)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".commsTimeout");
        }

        final State current ;
        synchronized(this)
        {
            if (!timerTask.equals(caller)) {
                // the timer was cancelled but it went off before it could be cancelled

                return;
            }

            current = state ;
        }

        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".commsTimeout. State: " + current);
        }

        if (current == State.STATE_COMPLETED)
        {
            sendCompleted(true) ;
        }
    }

    /**
     * Send the exit message.
     *
     */
    private void sendExit()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendExit. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            ParticipantCompletionCoordinatorClient.getClient().sendExit(coordinator, map, instanceIdentifier) ;
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Exit", th) ;
            }
        }
    }

    /**
     * Send the completed message
     */

    private void sendCompleted()
    {
        sendCompleted(false);
    }

    /**
     * Send the completed message.
     *
     * @param timedOut true if this is in response to a comms timeout
     */
    private void sendCompleted(boolean timedOut)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendCompleted. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            // if we are trying to reestablish the participant state then send getStatus otherwise send completed
            if (timedOut && checkStatus) {
                ParticipantCompletionCoordinatorClient.getClient().sendGetStatus(coordinator, map, instanceIdentifier); ;
            } else {
                ParticipantCompletionCoordinatorClient.getClient().sendCompleted(coordinator, map, instanceIdentifier) ;
            }
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Completed", th) ;
            }
        }

        // if we timed out the increase the resend period otherwise make sure it is reset to the
        // initial resend period

        updateResendPeriod(timedOut);

        initiateTimer() ;
    }

    private synchronized void updateResendPeriod(boolean timedOut)
    {
        // if we timed out then we multiply the resend period by ~= sqrt(2) up to the maximum
        // if not we make sure it is reset to the initial period

        if (timedOut) {
            if (resendPeriod < maxResendPeriod) {
                long newPeriod  = resendPeriod * 14 / 10;  // approximately doubles every two resends

                if (newPeriod > maxResendPeriod) {
                    newPeriod = maxResendPeriod;
                }
                resendPeriod = newPeriod;
            } else {
                // ok, we hit our maximum period last time -- this time switch to sending getStatus
                checkStatus = true;
            }
        } else {
            if (resendPeriod > initialResendPeriod) {
                resendPeriod = initialResendPeriod;
            }
            // if we were previously checking status we need to revert to sending Completed
            if (checkStatus) {
                checkStatus = false;
            }
        }
    }

    /**
     * Send the fail message.
     * @param message The fail message.
     *
     */
    private void sendFail(final QName message)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendFail. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            ParticipantCompletionCoordinatorClient.getClient().sendFail(coordinator, map, instanceIdentifier, message) ;
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Fault", th) ;
            }
        }
    }

    /**
     * Send the cancelled message.
     *
     */
    private void sendCancelled()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendCancelled. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            ParticipantCompletionCoordinatorClient.getClient().sendCancelled(coordinator, map, instanceIdentifier) ;
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Cancelled", th) ;
            }
        }
    }

    /**
     * Send the closed message.
     *
     */
    private void sendClosed()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendClosed. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            ParticipantCompletionCoordinatorClient.getClient().sendClosed(coordinator, map, instanceIdentifier) ;
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Closed", th) ;
            }
        }
    }

    /**
     * Send the compensated message.
     *
     */
    private void sendCompensated()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendCompensated. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            ParticipantCompletionCoordinatorClient.getClient().sendCompensated(coordinator, map, instanceIdentifier) ;
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Compensated", th) ;
            }
        }
    }

    /**
     * Send the status message.
     * @param state The state.
     *
     */
    private void sendStatus(final State state)
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendStatus. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            ParticipantCompletionCoordinatorClient.getClient().sendStatus(coordinator, map, instanceIdentifier, state.getValue()) ;
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Status", th) ;
            }
        }
    }

    /**
     * Send the cannot complete message.
     *
     */
    private void sendCannotComplete()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".sendCannotComplete. Coordinator: " + coordinator
                    + ", instance identifier: " + instanceIdentifier);
        }

        final MAP map = createContext() ;
        try
        {
            ParticipantCompletionCoordinatorClient.getClient().sendCannotComplete(coordinator, map, instanceIdentifier) ;
        }
        catch (final Throwable th)
        {
            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev("Unexpected exception while sending Status", th) ;
            }
        }
    }

    /**
     * Get the coordinator id.
     * @return The coordinator id.
     */
    public String getId()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".getId. Id: " + id);
        }

        return id ;
    }

    /**
     * Get the coordinator endpoint reference
     * @return The coordinator endpoint reference
     */
    public W3CEndpointReference getCoordinator()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".getCoordinator. Coordinator: " + coordinator);
        }

        return coordinator ;
    }

    /**
     * Get the associated participant.
     * @return The associated participant.
     */
    public BusinessAgreementWithParticipantCompletionParticipant getParticipant()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".getParticipant. Participant: " + participant);
        }

        return participant ;
    }

    /**
     * check whether this participant's details have been recovered from the log
     * @return true if the participant is recovered otherwise false
     */
    public boolean isRecovered()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".isRecovered. Recovered: " + recovered);
        }

        return recovered;
    }

    /**
     * Change the state and notify any listeners.
     * @param state The new state.
     */
    private synchronized void changeState(final State state)
    {
        if (this.state != state)
        {
            this.state = state ;
            notifyAll() ;
        }
    }

    /**
     * Wait for the state to change from the specified state.
     * @param origState The original state.
     * @param delay The maximum time to wait for (in milliseconds).
     * @return The current state.
     */
    private State waitForState(final State origState, final long delay)
    {
        final long end = System.currentTimeMillis() + delay ;
        synchronized(this)
        {
            while(state == origState)
            {
                final long remaining = end - System.currentTimeMillis() ;
                if (remaining <= 0)
                {
                    break ;
                }
                try
                {
                    wait(remaining) ;
                }
                catch (final InterruptedException ie) {} // ignore
            }
            return state ;
        }
    }

    /**
     * Execute the cancel transition.
     *
     */
    private void executeCancel()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".executeCancel. Participant: " + participant);
        }

        try
        {
            participant.cancel() ;
        }
        catch (final FaultedException fe)
        {
            WSTLogger.i18NLogger.warn_messaging_engines_ParticipantCompletionParticipantEngine_executeCancel_1(fe);

            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev(fe, "Faulted exception from participant cancel for WS-BA participant") ;
            }

            // fail here because the participant doesn't want to retry the cancel
            fail(BusinessActivityConstants.WSBA_ELEMENT_FAIL_QNAME);
            return;
        }
        catch (final Throwable th)
        {
            WSTLogger.i18NLogger.warn_messaging_engines_ParticipantCompletionParticipantEngine_executeCancel_2(th);

            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev(th, "Unexpected exception from participant cancel for WS-BA participant") ;
            }

            /*
             * we only get here in from state ACTIVE so if we are stll in state CANCELING then roll back the
             * state allowing a retry of the cancel
             */
            synchronized (this) {
                if (state == State.STATE_CANCELING) {
                    changeState(State.STATE_ACTIVE);
                }
            }
            return ;
        }
        sendCancelled() ;
        ended() ;
    }

    /**
     * Execute the close transition.
     *
     */
    private void executeClose()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".executeClose. Participant: " + participant);
        }

        try
        {
            participant.close() ;
        }
        catch (final Throwable th)
        {
            WSTLogger.i18NLogger.warn_messaging_engines_ParticipantCompletionParticipantEngine_executeClose_1(th);

            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev(th, "Unexpected exception from participant close for WS-BA participant") ;
            }

            // restore previous state so we can retry the close otherwise we get stuck in state closing forever
            changeState(State.STATE_COMPLETED);

            initiateTimer();
            return ;
        }
        // delete any log record for the participant
        if (persisted) {
            // if we cannot delete the participant record we effectively drop the close message
            // here in the hope that we have better luck next time..
            if (!XTSBARecoveryManager.getRecoveryManager().deleteParticipantRecoveryRecord(id)) {
                // hmm, could not delete entry -- leave it so we can maybe retry later
                WSTLogger.i18NLogger.warn_wst11_messaging_engines_ParticipantCompletionParticipantEngine_executeClose_2(id);
                // restore previous state so we can retry the close otherwise we get stuck in state closing forever

                changeState(State.STATE_COMPLETED);

                initiateTimer();

                return;
            }
        }
        sendClosed() ;
        ended() ;
    }

    /**
     * Execute the compensate transition.
     *
     */
    private void executeCompensate()
    {
        if (WSTLogger.logger.isTraceEnabled()) {
            WSTLogger.logger.trace(getClass().getSimpleName() + ".executeCompensate. Participant: " + participant);
        }

        try
        {
            participant.compensate() ;
        }
        catch (final FaultedException fe)
        {
            WSTLogger.i18NLogger.warn_messaging_engines_ParticipantCompletionParticipantEngine_executeCompensate_1(fe);

            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev(fe, "Faulted exception from participant compensate for WS-BA participant") ;
            }

            // fail here because the participant doesn't want to retry the compensate
            fail(BusinessActivityConstants.WSBA_ELEMENT_FAIL_QNAME);
            return;
        }
        catch (final Throwable th)
        {
            final State current ;
            synchronized (this)
            {
                current = state ;
                if (current == State.STATE_COMPENSATING)
                {
                    changeState(State.STATE_COMPLETED) ;
                }
            }
            if (current == State.STATE_COMPENSATING)
            {
                initiateTimer() ;
            }

            WSTLogger.i18NLogger.warn_messaging_engines_ParticipantCompletionParticipantEngine_executeCompensate_2(th);

            if (WSTLogger.logger.isTraceEnabled())
            {
                WSTLogger.logger.tracev(th, "Unexpected exception from participant compensate for WS-BA participant") ;
            }

            return ;
        }

        final State current ;
        boolean failRequired = false;
        synchronized (this)
        {
            current = state ;
            // need to do this while synchronized so no fail calls can get in on between

            if (current == State.STATE_COMPENSATING)
            {
                if (persisted) {
                    if (!XTSBARecoveryManager.getRecoveryManager().deleteParticipantRecoveryRecord(id)) {
                        // we have to fail since we don't want to run the compensate method again
                        WSTLogger.i18NLogger.warn_wst11_messaging_engines_ParticipantCompletionParticipantEngine_executeCompensate_3(id);
                        failRequired = true;
                        changeState(State.STATE_FAILING_COMPENSATING);
                    }
                }
                // if we did not fail then we can decommission the participant now avoiding any further races
                // we will send the compensate after we exit the synchronized block
                if (!failRequired) {
                    ended();
                }
            }
        }
        if (failRequired) {
            fail(BusinessActivityConstants.WSBA_ELEMENT_FAIL_QNAME);
        } else if (current == State.STATE_COMPENSATING) {
            sendCompensated() ;
        }
    }

    /**
     * End the current participant.
     */
    private void ended()
    {
	changeState(State.STATE_ENDED) ;
        ParticipantCompletionParticipantProcessor.getProcessor().deactivateParticipant(this) ;
    }

    /**
     * Initiate the timer.
     */
    private synchronized void initiateTimer()
    {
        if (timerTask != null)
        {
            timerTask.cancel() ;
        }

        if (state == State.STATE_COMPLETED)
        {
            timerTask = new TimerTask() {
                public void run() {
                    commsTimeout(this) ;
                }
            } ;
            TransportTimer.getTimer().schedule(timerTask, resendPeriod) ;
        }
        else
        {
            timerTask = null ;
        }
    }

    /**
     * Create a context for the outgoing message.
     * @return The addressing context.
     */
    private MAP createContext()
    {
        final String messageId = MessageId.getMessageId() ;

        return AddressingHelper.createNotificationContext(messageId) ;
    }
}

redpajama_set_name: RedPajamaGithub


text:
Gallis' "Études"
Dimosthenis Gallis launches a new style in his latest work under the title "Études" (Studies). With his photographic "nib pen," the photographer depicts fifteen single and fifteen double male nude portraits. The faces avoid looking towards the lens and thus society itself, as the latter has marginalized them due to their sexual choices. The bare and stripped of social "weights" bodies seek to remind us that they exist, live, feel, think, and pose, like any other human being on earth. Having renounced any kind of lust and fetishism regarding the rendering of bodies, Gallis aims to document a series of studies on these men's psyche, as they have chosen a different personal path in life (a reprehensible and forbidden path for a large part of the society). Thus, he dives photographically into the depths of their soul and brings into the surface common feelings to all people like loneliness, grief, and frustration. Even binary works exude the most profound solitude of the subjects, who, while appear to have a partner, are not experiencing companionship but a peculiar loneliness that seems even more prominent because of the semblance of togetherness. Their glances do not meet, the physical contact exists or smolders, but they have a total lack of soul encounter. We could describe Gallis as a realist, even a naturalist, as he reflects in his work a "slice of life" on the life of gay men. Regarding his technique, he is original, as he seems to have sketched his works with a nib pen, with clear outlines, highlighting the inner strength and entelechy of the bodies. Gallis here gets his inspiration by the human male anatomy studies of the 17th century and uses his photographic "pen nib" to demonstrate the robustness and autonomy of the bodies in space. The dynamic poses of the models conflict with the internal stagnation and the mental inertia. This stagnation does not act against the force that the works exude. It is a preliminary action stage, a respite before externalizing reaction against social exclusion. At this point rests the entelechy of the bodies: they are potential beings preparing to transform into active beings. Τhe process of preparing, which is painful and liberating at the same time, will lead to perfection, which is the aim of all people, regardless of their sexual choices. This process is necessary for a man to reach the much-desired happiness. The path towards this happiness is undoubtedly more difficult for the people whose sexual preferences are not compatible with the social requirements. Therefore, Gallis with "ÉTUDES" expresses not only a silent protest against the stereotypes but also a proof of the self-evident fact that even though people can be different, they remain equal and with the same emotional needs.
Karpouzis Stratos Art historian-Philologist

redpajama_set_name: RedPajamaCommonCrawl


text:
IC 759 ist ein nichtexistentes Objekt im Sternbild Coma Berenices am Nordsternhimmel, welches der Astronom Guillaume Bigourdan am 23. März 1887 fälschlich als IC-Objekt beschrieb.

Einzelnachweise

redpajama_set_name: RedPajamaWikipedia


I'm more of a straight-edges kind of girl. But polka dots? That's a different story...I love them. I thrifted these dotty tumblers last week and they add instant happiness wherever I set them down.
Yesterday I had the calling to cut and paste and turned that energy into two new train cases. These are the last of my stash and that's OK with me. I've been feeling the pull of a different crafty direction and clearing out the old makes room for new ideas...whatever that might be.
I am a creator; my inspiration comes from things I have in front of me and I always start a project by gathering a pile of supplies. Everything comes from that pile and the final design is always a surprise to me. I love that process.
Occasionally, I am a producer. I make 'more' versions of an original idea. I don't love that process...at least not for very long. This makes for bad business and disappointed friends (ack...so sorry...I haven't felt like making "insert item here"...guilty feeling).
Are you a creator that sometimes becomes a producer? Are you good at it or do you struggle? Do you move on to the next thing without looking back or...not?
Such an interesting post ... I feel like a "supply seller" more than anything these days, but when I've got the time, I create. I like to figure out how something is made, once, and then I'm usually done.
I am definitely more of a creator than a producer. I often have good intensions on replicate things but I lose interest and move on to the next beautiful thing.
I was wondering if you were the Patty from instagram...and you are! So glad you found me here and am also glad to now of have a new blog to read.
Yes!...donating back to the same thrift store where I got most of my stuff makes me happy...the circle of craftiness!
when i find something that i like to make, i want to make one million of them. after that i hate making the thing so much that i never want to make it again. so i understand about the "disappointed friends" when i just can't bear the thought of making one more hat, pillow, pair of gloves...all long lost obsessions.....love your blog!


text:
KGF 2 Teaser, Comes As A Birthday Gift To Yash
The celebrations have begun, Yash gets a Birthday Gift, the release of his upcoming movie KGF chapter 2's teaser. The filmmakers had initially planned a different release time, but things got changed, and had to release it immediately as the teaser was leaked on social media so, they decided that no other date would be better other than Yash's birthday. The expectations have been raised after watching the Promo. It is expected that the movie is going to be much bigger and much better than the previous version of it.
The teaser gives us a sight of all the main roles of the film. With this teaser, the audience gets to see new characters foraying into the film. The filmmakers in a way introduced characters like Rao Ramesh, Raveena Tandon, and the Bollywood Biggie Sanjay Dutt. Now with these talented actors stepping their foot into the movie, the expectations have certainly increased. The audience is eagerly waiting now for the release of the movie. The rocking entry of Yash, firing a Machine Gun Mounted on the tank, is the icing on the cake. The movie is set to release in Summer, simultaneously in Telugu, Tamil, Kannada, Hindi, and Malayalam.


BARDWELL, Texas (CBSDFW.COM) – A North Texas police chief and a volunteer firefighter were among five victims killed in a head-on crash Sunday morning in Ellis County near Bardwell.
The Texas Department of Public Safety responded to the major crash around 10:15 a.m. on Highway 34 near Highview Park Road.
Authorities say five people died in the crash.
Two of the victims killed were Bardwell Police Chief Michael Spurgeon Sr. and his son, Bardwell area volunteer firefighter Michael Spurgeon Jr., according to the town's volunteer fire department Facebook page.
Spurgeon Sr.'s wife later confirmed that her husband was killed in the crash.
Texas Motorplex offered its condolences to the father and son as they were "longtime friends" of the facility.


How will you be enjoying the weather this weekend?
Earlier this week, the Met Office issued an official heatwave alert, warning of an 80 per cent chance of heatwave conditions this week, with some parts of the UK tipped to reach temperatures as high as 35 degrees.
While Yorkshire hasn't quite reached those highs, with the warmest temperature for this month peaking at 28.5C on Tuesday 25 June at Linton-on-Ouse, the county has been enjoying the heat of the mid-20s all week - and it looks set to last into the weekend.
Tomorrow will see some cloud early on which will soon disperse through the first half of the morning, with largely unbroken sunshine to follow.
The air will feel a little fresher, although it will still be very warm inland, with a moderate easterly breeze and temperatures reaching around 24C in most parts.
In the Dales, temperatures are expected to climb to a hot 25C and will remain dry throughout, making it an ideal for walking and picnicing.
Sunday will see the dry, warm and sunny conditions prevailing, although some patchy low cloud is likley near coastal areas and inland overnight, with a brisk easterly breeze developing.
Temperatures are set to remain in the mid-20s across the region, with sunshine expected all day.


The Lenny Peters Foundation is proud to be a helping hand here at home in the Piedmont Triad and around the world in Dr. Lenny Peters' hometown of Kerala, India. Dr. Peters recognizes and remembers his humble origins and so, through the Foundation, the Jayamatha Boys Home in Kerala, India was founded.
The Jayamatha Boys Home is run by Franciscan Christian Missionaries who care for approximately 210 children in Nalanchira, the capital of Kerala. The Lenny Peters Foundation is leading the way to providing unbiased financial assistance to over 200 orphans there. This financial assistance provides housing, food and education to each and every orphan.
Jacob Pakkiam is an alumni of the Jayamatha Boys Home that the Lenny Peters Foundation supports. Jacob recounts his experience at the Jayamatha Boys Home below.
I came to the Jayamatha Boys Home after my father passed away and we had no house or way of making a living. I was able to pursue my studies in the Boys Home and with that background I studied at Jayamatha Industrial Training Institute (I.T.I). I passed the Printing technology exam by the Kerala State Government. For higher studies, I was sent to the Central Government Institution at Kanpur and I successfully completed the Instructor Course. Then I was posted as an Instructor at Jayamatha I. T. I. Thereafter, I passed the P. S. C. (Public Service Commission) test and I was posted as " proof reader" in the Kerala Govt. Press (Printing Department). Now I am retired from Govt. service. At present, I am working for the betterment of the Jayamatha Press.
During my life in Jayamatha, I received training in playing the clarinet, typewriting, in sports and arts, and also in agriculture. I acquired qualities like punctuality, self esteem, and a sense of justice and morality. I am a married man, now living in Monvila, with my wife and daughter, who is studying to be an accountant.
Now the old students of Jayamatha have formed an alumni association. It is a nice community that demonstrated to me how the Boys Home helped others succeed as well.
With sincere thanks, I remember the "Franciscan Brothers", who taught us at the Boys Home, for the graces received by me and many others all over Kerala. Also I thank God Almighty for everything.
The Lenny Peters Foundation is dedicated to helping people in their last few years of life – just to let them know someone cares. They are God's people, although not as privileged as many others. The Lenny Peters Foundation India staff and volunteers visit small, poor villages and find terminally ill or utterly poor people and show them God's blessings. The Lenny Peters Foundation gives these people envelopes with cash that they can use for anything they need. This is done on a daily basis in an area with several million people.
Because we work from a base of charitable donations, we welcome anyone who would like to contribute to the Jayamatha Boys Home or the Lenny Peters Girls Home through our nonprofit 501 (c) (3) charity. Donating funds to our charitable organization is always tax-deductible. Pledge now to help children in need. With $100 per month (or $1200 per year), you will be providing food, clothing, residence, education (grade 1 through high school), and job training.
You may request a photo of the child you are helping by contacting us directly.


With Labor Day behind us, summer is unofficially over.
It is still very hot here in Dallas, 103 F today, so forgive me if I am not ready to break into my fall comfort food recipes just quite yet. Peaches, for example, are still available at the farmer's market and as long as they are still available I can't pass the up. Soon, you see, they will be gone and the end of peach season is one of the saddest things about the end of summer. I got some very, very sweet peaches on my last shopping trip that I wanted to use in one last peachy recipe this year. I intended for these to be traditional thumb print cookies, because I wanted to showcase my caramel peach jam, but they spread – a lot! Instead these cookies are crisp and buttery with a peachy center. They are not exactly what I wanted, but one taste is all it took to know these were better than what I wanted! I love it when that happens!
The cookie part of this recipe was intended to be a vehicle for my caramel peach jam, but the cookie part surprised me by being as good, if not slightly better, than my excellent jam. So, let's start with the cookie. It is very buttery, crisp at the edges and chewy in the center thanks to the jam. There is no leavening agent in the cookies but they are in no way heavy. They would be lovely without the jam, but you would be missing out. That leads us to the jam which is made with brown sugar, a hint of spice, and cooked until it is VERY thick. You have to cook out the water from the peaches, so it takes a good 20 minutes once the mixture reaches a rolling boil to be just right. By cooking it until it is super thick you get a sticky, deeply caramel flavored jam that holds up well when baked into a cookie. This jam would also be good on toast, over ice cream, or eaten off a spoon – just saying.
In a medium pot combine the peaches, brown sugar, vanilla bean paste, lemon juice, cinnamon, and salt. Stir to combine then cook over medium-high heat until it reaches a rolling boil, about 3 minutes. Once boiling reduce the heat to medium and cook, stirring occasionally, until the mixture is very thick and a deep caramel color, about 20 to 25 minutes. Remove from the heat and cool slightly, then transfer the mixture to a blender and pulse until the mixture is roughly blended. Do not puree. Set aside to cool to room temperature.
In the work bowl of a stand mixer combine the flour, butter, brown sugar, sugar, and salt. Beat on low speed until the mixture clumps around the paddle, about 1 minute. Add the milk, bourbon, and vanilla and mix on low speed until the mixture is smooth, about 1 minute.
Scoop the dough into 1-inch balls, then press your thumb or a teaspoon, into the center of the cookies. Fill the center of each cookie with 1/2 teaspoon of jam, spreading it gently so it is in an even layer. Bake for 10 to 12 minutes, or until the cookies are golden brown at the edges. Cool on the pan 5 minutes, then transfer to a wire rack to cool completely.


Research on project controls has mainly focused either on their direct effect on project outcomes, or on the joint effect of controls and other factors on such outcomes. A few studies have examined the impact of control mechanisms on teamwork processes, usually with the aim of ascertaining why a particular mechanism is needed, or how control affects final outcomes. This study goes further, exploring control mechanisms' influence on teamwork and how this influence, in turn, leads to changes in project performance. Moreover, while many past studies have only examined the extent to which controlees can effectively perform their tasks, this one looks at in-role and extra-role behaviors as process variables; and, instead of treating control as a single undifferentiated phenomenon, it models the integrated effects of formal and informal (clan) control on projects. Analysis of data collected from 220 practitioners shows that both types of formal control mechanisms and clan control had distinctive impacts on both in-role and extra-role behaviors, and that both these behavior types had identifiable impacts on project performance. When formal and clan control mechanisms were applied simultaneously, in-role behavior was reduced and extra-role behavior increased. We conclude with a discussion of our findings' implications for past and future control studies as well as for practitioners.


text:
Antonio di Pietro Averlino (Florence, 1400- Rome,1469 ), beter bekend als Filarete ( In het Grieks: vriend van de deugd), was een Italiaanse architect, beeldhouwer en traktaatschrijver. Hij is vooral bekend om zijn twee bronzen deuren voor de Sint-Pietersbasiliek, het Ospedale Maggiore, en zijn architectuurtheoretisch traktaat "Trattato di archittettura" dat hij schreef op het einde van zijn leven.

Geschiedenis
Antonio Averlino groeide op tijdens de beginperiode van de Renaissance in zijn geboortestad Florence, die toen een enorme culturele bloei kende en tevens het artistieke centrum was van Italië. Daar werd hij door Lorenzo Ghiberti, edelsmid, beeldhouwer en schilder, opgeleid in de techniek van het bronsgieten. Het was van hem dat hij zijn Griekse pseudoniem "Filarete" kreeg. Zijn eerste werken bestonden vooral uit bronzen beelden, die mythologische en Bijbelse thema's toonden. In 1430 reisde hij naar Rome om daar de Romeinse overblijfselen te bestuderen. Daar kreeg hij rond 1433 de opdracht van paus Eugenius IV om twee bronzen deuren te vervaardigen voor de Sint-Pietersbasiliek. In 1448 verliet hij Rome, nadat hij beschuldigd werd van het stelen van een relikwie, en vestigde zich in Milaan (hij ging eerst nog naar Florence). Daar werkte hij als architect voor hertog Francesco Sforza, onder wie hij in 1457 het Ospedale Maggiore verwezenlijkte. Op het einde van zijn leven, in 1465, schreef hij zijn "Trattato di archittettura", een traktaat waarvan aanvankelijk de waarde niet werd onderkend, totdat het in de 19de eeuw werd herontdekt en heruitgegeven. Vervolgens zou hij volgens sommige bronnen in 1466 teruggekeerd zijn naar zijn geboortestad Florence, maar uit geschriften van Francesco Filelfo zou men ook kunnen afleiden dat hij naar Constantinopel is uitgeweken. Filarete leefde deels in de schaduw van zijn tijdgenoot Leon Battista Alberti, een alom geprezen filosoof, architect en kunstenaar, bekend door zijn traktaat "De Re aedificatoria" dat soms haaks op dat van Filarete staat. Volgens de overgebleven bronnen van Giorgio Vasari zou hij gestorven zijn in 1469 te Rome.

Werken

De bronzen deuren van de Sint-Pietersbasiliek

In 1433 kreeg Filarete de opdracht van paus Eugenius IV om de twee bronzen deuren voor de oude Sint-Pietersbasiliek te vervaardigen. Deze werden voltooid in 1445 en werden na de afbraak van de Oude Sint-Pieter verplaatst naar de Nieuwe Sint-Pieter die omstreeks 1619 werd gebouwd. In het bronzen reliëf zijn naast 25 medailles ook 7 verschillende soorten wezens afgebeeld (waaronder dieren, Grieken, Romeinen en heiligen). Het belangrijkste is dat deze verschillende wezens ons een idee geven van de gedachten van Filarete, een gedachte van middeleeuwse complexiteit.

Het ruiterbeeld van Hector
In de jaren na zijn opleiding door Lorenzo Ghiberti vervaardigt Filarete enkele bronzen beelden, waarvan het ruiterbeeld van Hector het enige gesigneerde overgebleven kleine bronzen beeld van Filarete's Milanese periode is. Het is gemaakt in 1456 en verwijst naar een Venetiaans gedicht, "het lied van Hector en Hercules", waarin Hector Hercules verslaat in een duel. Het gedicht werd opgeslagen in de "Visconti" bibliotheek in Pavia, die in 1451 in het bezit kwam van Francesco Sforza. Vandaar zou het beschikbaar geweest zijn voor Filarete.

Ospedale Maggiore
In 1457 start Filarete aan de Ospedale Maggiore in Milaan, een van de eerste voorbeelden van de Renaissance architectuur in Lombardije en een aanzet voor nieuwe normen van comfort en sanitaire voorzieningen. Het deels uitgevoerde plan bestaat uit twee vierkanten, waartussen een groot rechthoekig plein gelegen is met als centraal punt een kapel. Beide vierkanten worden door middel van een kruis onderverdeeld in 4 kleinere vierkanten pleinen. Door zijn eenvoudige geometrie moest de opzet van zijn ontwerp in één oogopslag duidelijk worden. Verder werkte hij ook nog aan de Duomo van Milaan en het Castello Sforesco.

Trattato di archittettura

Rond 1465 schreef Filarete zijn Trattato di archittettura. Het traktaat is in vergelijking met vele traktaten uit die tijd een bijzonder geval. De twee bekendste versies van het traktaat zijn de codex Magliabechianus (25 delen), opgedragen aan Piero di Cosimo de' Medici, en de reeds verloren versie opgedragen aan Francesco Sforza (24 delen). In de eerste drie boeken wordt er kennisgemaakt met de protagonisten en de basismaterialen, meeteenheden en de beginselen van de architectuur. De volgende twee vertellen het verhaal van het bouwen, ommuren en versterken van de stad in 20 dagen door een leger van 102.000 werkers. De overige 16 boeken bevatten de constructie van individuele gebouwen, de bouw van Plusiapolis ( zie plan en gevel rechts), en de sociale organisatie in de stad. Dit alles wordt doorheen het hele traktaat gelinkt aan het bouwen van de ideale stad Sforzinda. Hierbij zijn nog eens drie boeken toegevoegd over het tekenen en schilderen. En bij de versie voor Piero di Cosimo de 'Medici is er nog een extra boek toegevoegd met de grootste bouwwerken van de familie Medici. In tegenstelling tot Vitruvius en Alberti is het traktaat geschreven voor het plebs, in een soort dialoog tussen de architect (Filarete) en Francesco Sforza's zoon. Dit toont aan dat de opdrachtgever bij Filarete een belangrijke rol krijgt. Giorgio Vasari had echter veel kritiek op de schrijfstijl van Filarete en noemde het traktaat een idiotie, waardoor de tekst in de vergetelheid raakte werd en pas in de 19de eeuw herontdekt werd.

Zijn 8e boek staat centraal, hierin vertelt Filarete dat zijn regels beschreven in zijn boeken niet definitief maar eerder beschrijvend zijn. Hij stelt dat elke architect vrij is om regels te gebruiken die niet door hemzelf geschreven zijn en dat het kiezen van die regels eerder een kwestie is van smaak dan van rede. Volgens hem is het hoofdkenmerk van de architectuur de aanblik en verschijning van een gebouw, en hij gebruikt daarvoor strenge geometrische vormen, met het vierkant als ideale vorm (Brunelleshi's kerksysteem). Verder gelooft hij dat zijn theorie en methode van ontwerpen de antieke kunsten representeert, en hij spreekt zich negatief uit tegenover de Noord-Italiaanse Gotiek en prijst de antieke bouwstijl. Alhoewel zijn Gotisch uitziende tekeningen dit soms tegenspreken.

Er zijn reeds vele vragen gerezen waarom en hoe Filarete dit enorme traktaat geschreven zou hebben (het is ook gebleken dat hij wel degelijk kennis moest hebben van traktaten zoals die van Alberti en Vitruvius), en tot op vandaag is daar geen zekerheid over. Het meest aanneembare antwoord is dat zijn vriend Francesco Filelfo – een goede vriend van Filarete – hem geholpen heeft bij het maken van het traktaat. Filelfo was een schrijver en vertaler van oude Griekse en Romeinse traktaten, waarvan enkele onderdelen herkenbaar zijn in Filaretes traktaat.

Vergelijking met Alberti's architectuurtheorie

Filarete neemt in zijn traktaat opmerkelijk andere standpunten in dan Alberti in zijn "De re aedificatoria". Zo is in tegenstelling tot Alberti's traktaat, de architectuur ontstaan doordat de eerste mens, Adam, beschutting zocht voor de regen en zo eerst wat takken, vervolgens wat bladeren en vervolgens een dak boven zijn hoofd hield. Zo was volgens Filarete, Adam de eerste die architectuur beoefende.

Filarete is ook de eerste die de positie van de architect in zijn traktaat onderzoekt. Volgens hem moeten de architect en de opdrachtgever gedurende negen maanden het huis dragen en in goed overleg met elkaar gedurende die negen maanden het huis voeden en veranderen waar nodig is. Daarom is het gebruik van tekeningen volgens Filarete zo belangrijk (hij voegt om die reden ook drie extra boeken over tekenen en schilderen bij het traktaat toe), namelijk omdat de tekeningen de architect helpen bij het ontwikkelen van plannen en bij het presenteren van ontwerpen aan de bouwheer en omdat ze belangrijk zijn op de werf. Dit in tegenstelling tot Alberti, die de tekeningen misleidend vindt, terwijl hij de maquette zeer belangrijk vindt (omzetting maquette-gebouw). Filarete daarentegen gebruikt de maquette alleen als 3D-model en voor de materialisatie (omzetting tekening-gebouw). Filarete neemt een humanistisch standpunt in als hij zegt dat goede afmetingen voor gebouwen zijn afgeleid van een goed geproportioneerd menselijk lichaam. Dit is opnieuw een eigen variatie op Vitruvius en Alberti.

Verder kunnen we stellen dat Filarete het traktaat op het einde van zijn leven heeft geschreven, terwijl Alberti het traktaat schreef aan het begin van zijn carrière als architect. Dit heeft tot gevolg dat Alberti's traktaat afwijkt van diens latere architectuur, terwijl dit bij Filarete veel minder het geval is.

Conclusie
Alhoewel Filaretes traktaat tot in de 19e eeuw eigenlijk in de schaduw stond van de traktaten van Alberti en Vitruvius, is het traktaat van Filarete vandaag de dag een van de belangrijkste traktaten uit de Renaissance en het quattrocento. Bovendien is Filaretes traktaat tegelijk verwant en enorm verschillend van die van Vitruvius en Alberti.

Bibliografie
BECK, J. H., 'review: Trattato d'Architettura. by Antonio Averlino detto il Filarete', Renaissance Quarterly, Vol. 27, No. 4, 1974, pp. 563-564.
BUHLER, C. F., 'Filarete's Trattato D' Architettura', Renaissance News, Vol. 10, No. 1, 1957, pp. 18-19.
IL FILARETE; DI PIERO AVERLINO, A.; SPENCER, J. R., 'On the Origins of Architecture', Perspecta, Vol. 17, 1980, pp. 6-7.
LANG , S., 'Sforzinda, Filarete, Filelfo' ,Journal of the Warburg and Courtauld Institutes, Vol. 35 (1972), pp. 391-397, The Warburg Institute
LICHT, M.; TIGLER, P., 'review: Filarete's Treatise on Architecture by John R. Spencer', The Art Bulletin, Vol. 49, No. 4, 1967, pp. 351-360.
SAALMAN, H., 'Early Renaissance Architectural Theory and Practice in Antonio Filarete's Trattato di Architettura', Vol. 41, No. 1, 1959, pp. 89-107.
SCHULZ, J., revieuw SPENCER, J.R., Treatise on Architecture by Filarete, The Journal of Aesthetics and Art Criticism, Vol. 25, No. 4 (Summer, 1967), pp. 472- 473, Blackwell Publishing on behalf of The American Society for Aesthetics
SPENCER, J. R., 'review: Antonio Averlino detto il Filarete. Tratato di Architettura by Anna Maria Finoli ; Liliana Grassi', The Art Bulletin, Vol. 57, No. 1, 1975, pp. 131-133.
SPENCER, J. R., 'The Dome of Sforzinda Cathedral', The Art Bulletin, Vol. 41, No. 4, 1959, pp. 328-330.

Externe link
  Meer info over Filarete
  Bronzen deuren van Sint-Pieters

Italiaans architect
Italiaans beeldhouwer
Renaissance-architect
Renaissancebeeldhouwer
15e-eeuws kunstenaar


text:
England's U turn on...
England's U turn on covid-19 vaccine mandate for NHS staff
BMJ 2022; 376 doi: https://doi.org/10.1136/bmj.o353 (Published 10 February 2022) Cite this as: BMJ 2022;376:o353
Martin McKee, professor of European public health,
May C I van Schalkwyk, NIHR doctoral fellow
London School of Hygiene and Tropical Medicine, London, UK
Correspondence to: M McKee martin.mckee{at}lshtm.ac.uk
An avoidable and costly episode that raises concerning questions about governance
Two years into a pandemic, with hopes of respite for exhausted healthcare workers repeatedly shattered by the emergence of new SARS-CoV-2 variants, those in charge in the NHS just want certainty. So it is little wonder that, over the past few weeks, they have become increasingly frustrated as they struggle to interpret the government's changing intentions for vaccination of their staff. But when this is over we should all reflect on what this episode says about how the country is being run.
On 9 November 2021, the health secretary told parliament that nearly all NHS staff must be vaccinated against covid-19 by April 2022,1 enacting the necessary legislation in a statutory instrument laid before parliament on 6 January 2022.2 Although controversial, mandates have been found to increase vaccine uptake.3 Staff had until 3 February to receive a first vaccine dose or risk losing their job. Since the mandate was first announced, almost 130 000 staff have come forward to be vaccinated. But others did not, with about 5% of NHS staff expected to miss the deadline.4
Occupational health and human resources departments have had the challenging task of confirming the vaccine status of staff, some of whom may have been vaccinated abroad or under a different name from the one used at work. They then had to contact everyone who seemed unvaccinated, confirm their status, ensure they were aware of the consequences and, often, spend time providing reassurance about vaccine safety. This was a massive undertaking in a service already struggling with high rates of sickness absence related to covid-19. Universities training health professionals had to do the same for their students, at great expense.
Throughout this time, NHS employers were voicing concern about the risk of losing key staff. By late January stories were emerging that the government was considering a U turn. Meanwhile, those working to implement the policy were questioning whether the mandate would be enforced. Some sort of an answer came on 31 January when the health secretary announced that he was launching a consultation on his intention to revoke it.5
Lack of clarity
However, the legislation remains in place for now, posing a problem for NHS employers. Should they uphold the law as it stands or pretend that it never existed and, reasonably, assume that the government will not hold them responsible for failure to implement it? Of course, the possibility remains that someone else might—through judicial review. On several occasions during the pandemic the courts have had to remind ministers that adherence to the law—for example, on procurement of personal protective equipment—is not optional. And notwithstanding any future change in the law, the chief medical officer and others have made clear that getting vaccinated is a professional responsibility,6 with implications for regulators and appraisers.
Could this unsatisfactory situation have been avoided? A report by a House of Lords committee that scrutinised the statutory instrument enabling the vaccine mandate is revealing.7 The report noted how the draft instrument lacked detail on key expressions, such as "face to face" contact. It criticised the accompanying explanatory memorandum, which "lacks all practical detail," "fails to provide an evidence based argument," and does not mention lessons from earlier legislation on mandatory vaccination for workers in care homes.
The Lords report further questioned assumptions in the impact assessment, noting that the committee would expect to be given "very strong evidence," given the risks, but the health department "has signally failed to do so." It raised concerns about the lack of contingency plans for potential loss of staff. The committee then describes how, "Searching through these other documents has provided us with some understanding of what is intended" but expresses concern about how "Unclear definitions may be 'interpreted' … to exceed what the legislation actually requires."
This episode is yet another example of how the process of making policy in Westminster is broken. Ideas, developed without consulting those affected, are briefed to friendly journalists. Parliamentary scrutiny is ignored. Those on the frontline are left guessing about what to do with unworkable legislation. It seems as if our political leaders view the classic text on governance in the UK, The Blunders of our Governments,8 written by the political scientists Anthony King and Ivor Crewe in 2013, not as a warning but as a manual for how to run the country.
Competing interests: We have read and understood BMJ policy on declaration of interests and declare that MM is a member of Independent SAGE. He also sits on the Medical Schools Council, whose members have been affected by this confusion.
Provenance and peer review: Commissioned; not externally peer reviewed.
This article is made freely available for personal use in accordance with BMJ's website terms and conditions for the duration of the covid-19 pandemic or until otherwise determined by BMJ. You may download and print the article for any lawful, non-commercial purpose (including text and data mining) provided that all copyright notices and trade marks are retained.
https://bmj.com/coronavirus/usage
Secretary of State for Health and Social Care. Oral statement to parliament on vaccines as a condition of deployment. 2021. https://www.gov.uk/government/speeches/health-secretary-statement-on-vaccines-as-a-condition-of-deployment
The Health and Social Care Act 2008 (Regulated Activities) (Amendment) (Coronavirus) (No 2) Regulations 2022. https://www.legislation.gov.uk/uksi/2022/15/made/data.pdf
Mills MC,
Rüttenauer T
. The effect of mandatory COVID-19 certificates on vaccine uptake: synthetic-control modelling of six countries. Lancet Public Health2022;7:e15-22. doi:10.1016/S2468-2667(21)00273-5 pmid:34914925
Iacobucci G
. Covid-19: government abandons mandatory vaccination of NHS staff. BMJ2022;376:o269. doi:10.1136/bmj.o269 pmid:35105551
Javid S. Vaccination: condition of deployment. Statement to the House of Commons, 31 Jan 2022. https://www.theyworkforyou.com/debates/?id=2022-01-31b.70.0
Gallagher P. Chris Whitty tells NHS staff it is their 'professional duty' to get the Covid vaccine. i News 2022 Feb 8. https://inews.co.uk/news/health/chris-whitty-nhs-staff-professional-duty-covid-vaccine-1448051
House of Lords Secondary Legislation Scrutiny Committee. 21st report of session 2021-22. https://committees.parliament.uk/publications/7989/documents/82445/default
King A,
Crewe I
. The blunders of our governments.OneWorld, 2013.
Martin McKee professor of European public health, May C I van Schalkwyk NIHR doctoral fellow
McKee M, van Schalkwyk M C I.
England's U turn on covid-19 vaccine mandate for NHS staff BMJ 2022; 376 :o353 doi:10.1136/bmj.o353
Articles by Martin McKee
Articles by May C I van Schalkwyk
You are going to email the following England's U turn on covid-19 vaccine mandate for NHS staff


text:
Q: Shiny causing dataset in googleVis to have differing number of rows I am trying to use Shiny to create a googleVis Bubble Chart. Outside of the Shiny server this code works fine:
df=data.frame(states=gun_stats$new_states, household=gun_stats$Gun.Ownership..2007., murder=gun_stats$Gun.Murder.Rate.per.100K..2010.,
          attack_size=gun_stats$state_attacks,attack_size_group=gun_stats$attack_category,
          gun_stats$x)

Bubble <- gvisBubbleChart(df, idvar="states", xvar="household", yvar="murder",colorvar="attack_size", sizevar="attack_size",
                      options=list(hAxis="{title:'% Housholds with Guns'}",
                                   vAxis="{title: 'Gun muder rate per 100k'}",height="600"))
plot(Bubble)

Then I try to put it in a Shiny app as follows:
server.R
shinyServer(function(input, output, session) {

    df=data.frame(states=gun_stats$new_states, household=gun_stats$Gun.Ownership..2007., murder=gun_stats$Gun.Murder.Rate.per.100K..2010.,
              attack_size=gun_stats$state_attacks, attack_size_group=gun_stats$attack_category)

    output$chart <- renderGvis({
    gvisBubbleChart(df, idvar="states", xvar="household", yvar="murder",colorvar="attack_var", sizevar="attack_var",
                    options=list(hAxis="{title:'% Housholds with Guns'}",
                                 vAxis="{title: 'Gun muder rate per 100k'}",height="600"))
    })
})

ui.R
library(googleVis)
library(shiny)
pageWithSidebar(
headerPanel("Mass Shootings Overview"),
     sidebarPanel(
        selectInput("attack_var", "Choose a size metric",
                    choices = c("x", "attack_size"))
    ),
mainPanel(htmlOutput('chart'))
)

However this returns: Error in data.frame: arguments imply differing number of rows: 51,0
Any suggestions?

redpajama_set_name: RedPajamaStackExchange


text:
Las Vegas Aces, WNBA
Las Vegas Aces free agency primer
Date: January 19, 2020Author: Matthew Hallett 0 Comments
The Las Vegas Aces managed to finish fourth last season after the acquired Liz Cambage via trade. This season they have a level of uncertainty with Cambage entering free agency.
The Las Vegas Aces delivered on the potential they have been developing over the past number of years. All it took was to drop in a generational played like Liz Cambage and they made it to fourth last season.
Coach Bill Laimbeer had the luxuty of playing the two headed monster that was Cambage and A'ja Wilson. Surrounding these two were shooters Kayla McBride and Kelsey Plum with rookie Jackie Young running the show. The chemistry between this starting unit will only improve if they stay together.
Thanks to the Cambage trade the Aces do not have a first round pick in the draft, nor do they have a second round pick. The only pick the Aces hold in the 2020 WNBA draft is the 33rd pick. Lets take a look at the players the Aces can re-sign.
Liz Cambage
Last summer the question around the league was who was going to get Liz Cambage via trade. We all know the answer to that as Cambage was able to help the Aces from out of playoff contention to fourth in the leagus. Cambage averaged 15.9 points, 8.2 rebounds, 2.1 assists and 1.6 blocks per game.
Cambage also shot 50.4 percent from the floor. At 6'8″ she is also quite a good 3-point shooter Her 16.7 percent shotting from deep last season does not support this but Cambage is used inside in Bill Laimbeer's system.
Cambage needs to develop the high/low chemistry with A'Ja Wilson that she has had with fellow Australian Cayla George when they were both with the Dallas Wings and the Australian national team. When this is working, any team with Cambage on it is impossible to stop.
Sending all of our love and support 🙏❤ https://t.co/o6vUzYMgFk
— Las Vegas Aces (@LVAces) January 7, 2020
This season the Aces are going to look to take the next step and they need to sign the Australian center as their top priority
Sugar Rodgers
Sugar Rodgers played all but one game last season, coming off the bench for all of them. While she only averaged 3.4 points, 1.5 rebounds and 1.2 assists per game. Her numbers do not tell the story of her impact on the team.
She is a steady ball handler who can light it up from deep. In order to give the Aces a different look when she comes off the bench, signing Rodgers is a good start to secure the success of the bench.
Tamera Young
Tamera Young is still one of the best defenders in the WNBA. She still believes that she defend anyone and on her showing last year, there is no one who can dispute this claim.
On top of her defense, Young averaged 5.3 points, 3.6 rebounds, 2.0 assists and 0.7 steals per game/ She shot the ball at a respectable 38.0 percent from the floor and 31.3 percent from deep. While she is not going to take over the game offensively, her defense combined with her offense make her a solid signature.
Carolyn Swords
Carolyn Swords is a really good back up for a player like liz Cambage. The Australian center is not as strong on defense as she could be. Swords is able to come in and change the course of a game through her defense. She si also a low cost backup on a team with five genuine stars.
Jaime Nared
Jaime Nared played one minute of basketball in the 2019 season. Expect her not to be on the roster next season.
Las Vegas AcesLiz Cambage
Previous Previous post: Los Angeles Sparks free agency primer
Next Next post: Minnesota Lynx free agency primer


text:
UFC 12: Judgement Day fue un evento de artes marciales mixtas celebrado por Ultimate Fighting Championship realizado el 7 de febrero de 1997 en el Dothan Civic Center en Dothan, Alabama.

Historia
UFC 12 fue el primer evento de UFC en ofrecer clases de peso; pesos pesados (200 libras o más) y peso ligero (199 libras o menos) se enfrentaron en dos mini torneos, cada uno compuesto por dos peleas de semifinales y el combate final.

Resultados

Peso ligero

Peso pesado

Desarrollo

Peso ligero

1 Nick Sanzo reemplazo a Yoshiki Takahashi que se retiró debido a una fractura en la mano.

Peso pesado

Véase también
 Lista de eventos de UFC

Referencias

Enlaces externos
 Resultados de UFC 12 en Sherdog.com
 Peleas de UFC 12
 Página oficial UFC
 Historia de UFC 12

Eventos de UFC
Artes marciales mixtas en Alabama


Hamilton-Whitten and Atkin-Colby halls were home to thousands of Illinois State students through the years before they were decommissioned in 2012.
Today, the halls are empty and awaiting demolition. That demolition work is expected to begin in summer 2015 and last around six months. The land will eventually be used to build a new home for Mennonite College of Nursing, according to Illinois State's master plan.


text:
Here's the Real Reason for Sky-High Home Prices, According to New Research
By: Sarah Hansen
Sarah Hansen
Sarah Hansen is a senior writer at Money covering all things personal finance. Previously, she covered economic policy and capital markets on the breaking news desk at Forbes.
Renting Is Cheaper Than Buying a Home in Most of the U.S. Right Now
Home Values Are Falling the Most in These 7 Cities: Zillow
Here's How Low Mortgage Rates Could Drop in 2023, According to One Expert
The 12 Cities Where Home Prices Dropped the Most in 2022
Here's How Many Homeowners Could Be Stuck With 'Underwater' Mortgages in 2023
Published: May 20, 2022 4 min read
https://money.com/reason-high-home-prices-remote-work/
Is there a housing bubble? On the surface it sure could look like that: Home prices have soared soared roughly 20% in the past year alone, pushing affordable housing out of reach for many hopeful buyers.
But according to a new paper published by the National Bureau of Economic Research, more than half of the 24% price growth between the end of 2019 and November 2021 was fueled by the pandemic-induced shift to remote work — not the price speculation that is typical of asset bubbles.
Authors John A. Mondragon of the Federal Reserve Bank of San Francisco and Johannes Wieland of the University of California, San Diego, also found that government stimulus measures during the pandemic (which have been criticized for their role in stoking inflation) were "less important factors" than remote work when it comes to housing prices.
The advent of remote work was largely responsible for an explosion in demand for housing, the researchers reported. As employers adopted flexible work-from-home policies over the last two years, employees sought out more space, often in cheaper and sunnier cities like Phoenix and Tampa.
Rock-bottom mortgage rates also meant potential buyers could afford more house for lower monthly payments. And with new construction constrained by supply chain issues, there simply haven't been enough homes on the market to satisfy the number of people looking to buy. That led to ultra-competitive bidding wars and sky-high prices.
The paper's authors call this a "fundamentals-based" explanation for price growth, meaning that the rise in home prices is linked to measurable market forces like supply and demand, mortgage rates and new construction. Bubbles, on the other hand, happen when prices become "unhinged from fundamentals."
Though worries about a new housing bubble have persisted, experts say today's market looks very different from 2008.
"My feeling is we could see a leveling off in prices, but not a 20-to-50 percent drop," Anne K. Thompson, co-author of a recent paper on homebuyer behavior, recently told the Brookings Institution. "People probably wouldn't lose their homes."
Mortgage Rates are expected to increase — act now
Now is the time to get ahead of rising Mortgage Rates. To lock in your rate, just click below and take the first step.
Remote work and the future of the housing market
With more than 40% of people working remotely either full- or part-time as of last November, it's clear that the lifestyle changes brought on by the pandemic aren't going away any time soon — especially given the popularity of working from home.
The researchers suggest that if remote work persists in the long term, increased housing costs could have a major impact on inflation, which in turn shapes federal monetary policy and the path of the economy more broadly. If remote work fades away, on the other hand, the researchers suggest that home prices could fall.
Either way, they wrote, "the future of remote work may be critical for the path of housing demand and house prices going forward."
Every Saturday, Money dives deep into the world of real estate, offering a fresh take on the latest housing news for homeowners, buyers and daydreamers alike.
By clicking "Sign Up" I agree to receive newsletters and promotions from Money and its partners. I agree to Money's Terms of Use and Privacy Notice and consent to the processing of my personal information.
Subscribe successful!
You will now receive Money's newsletter at
Reply anytime to let us know how we can improve. Enjoy!
Make sure we land in your inbox, not your spam folder. We just sent you a welcome email. Sometimes email clients send our first email to a spam or promotions folder. If you don't see us in your inbox, check these folders, then drag and drop the welcome email into your inbox.
Bubble or No Bubble? What History Tells Us About the Likelihood of a Housing Crash This Year
Why the Housing Market Isn't Cooling Off, Even as Prices and Mortgage Rates Surge
8 Best Mortgage Refinance Companies of May 2022


Figure drawing session at GHC with Julia last night went well. Julia raised her model game with an impressive showing where she was adorned with two separate costumes. She did really well.
I feel I did alright but was still quite tight even on the final two 25-minute poses. Charcoal pencil on old drawing paper and then newsprint.