closet organizer blueprints closet organizer plans wardrobe closet design inspiration of closet organizer plans pallet closet organizer plans closet organizer plans woodworking.
closet organizer boxes organizers as well design plans pallet do it yourself,pallet closet organizer plans free design build woodworking wooden medicine,closet organizer design plans free diy do it yourself benefits and a buying guide,easy small closet organizer plans woodworking shelving free design diy,custom closet organizer plans diy small shelves organizers value how to,closet organizer plans free shelves customize your closets woodworking,closet organizer plans woodworking building custom diy small walk in,closet shelving system with storage bins organizer plans woodworking free design diy small,closet shoe organizer plans build do it yourself diy wood,walk in closet organization ideas best closets y images on dream organizer plans diy kreg free design.
closet organizer boxes organizers as well design plans pallet do it yourself,pallet closet organizer plans free design build woodworking wooden medicine,walk in closet organization ideas best closets y images on dream organizer plans diy kreg free design,closet organizer plans woodworking building custom diy small walk in,easy small closet organizer plans woodworking shelving free design diy,closet shoe organizer plans build do it yourself diy wood,closet organizer design plans free diy do it yourself benefits and a buying guide,closet organizer plans free shelves customize your closets woodworking,custom closet organizer plans diy small shelves organizers value how to,closet shelving system with storage bins organizer plans woodworking free design diy small.


text:
// Copyright 2007-2012 Chris Patterson, Dru Sellers, Travis Smith, et. al.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

using System;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using Burrows.Context;
using Burrows.Endpoints;
using Burrows.Transports.Bindings;
using Burrows.Transports.PublisherConfirm;
using Magnum;
using RabbitMQ.Client;
using RabbitMQ.Client.Exceptions;

namespace Burrows.Transports.Rabbit
{
    public class OutboundRabbitTransport : IOutboundTransport
    {
        private readonly IRabbitEndpointAddress _address;
        readonly bool _bindToQueue;
        private readonly PublisherConfirmSettings _publisherConfirmSettings;
        private readonly IConnectionHandler<TransportConnection> _connectionHandler;
        ProducerBinding _producer;

        public OutboundRabbitTransport(IRabbitEndpointAddress address,
            PublisherConfirmSettings publisherConfirmSettings,
            IConnectionHandler<TransportConnection> connectionHandler, bool bindToQueue)
        {
            _address = address;
            _publisherConfirmSettings = publisherConfirmSettings;
            _connectionHandler = connectionHandler;
            _bindToQueue = bindToQueue;
        }

        public IEndpointAddress Address
        {
            get { return _address; }
        }

        public void Send(ISendContext context)
        {
            AddProducerBinding();

            _connectionHandler.Use(connection =>
            {
                try
                {
                    IBasicProperties properties = _producer.CreateProperties();

                    properties.SetPersistent(context.DeliveryMode == DeliveryMode.Persistent);
                    properties.MessageId = context.MessageId ?? properties.MessageId ?? NewIds.NewId.Next().ToString();
                    if (context.ExpirationTime.HasValue)
                    {
                        DateTime value = context.ExpirationTime.Value;
                        properties.Expiration =
                            (value.Kind == DateTimeKind.Utc
                                ? value - SystemUtil.UtcNow
                                : value - SystemUtil.Now).
                                TotalMilliseconds.ToString("F0", CultureInfo.InvariantCulture);
                    }

                    using (var body = new MemoryStream())
                    {
                        context.SerializeTo(body);
                        properties.Headers = context.Headers.ToDictionary(entry => entry.Key,
                            entry => (object) entry.Value);
                        properties.Headers["Content-Type"] = context.ContentType;

                        _producer.Publish(_address.Name, properties, body.ToArray());

                        _address.LogSent(context.MessageId ?? properties.MessageId ?? "", context.MessageType);
                    }
                }
                catch (AlreadyClosedException ex)
                {
                    throw new InvalidConnectionException(_address.Uri, "Connection was already closed", ex);
                }
                catch (EndOfStreamException ex)
                {
                    throw new InvalidConnectionException(_address.Uri, "Connection was closed", ex);
                }
                catch (OperationInterruptedException ex)
                {
                    throw new InvalidConnectionException(_address.Uri, "Operation was interrupted", ex);
                }
                catch (IOException ex)
                {
                    if (ex.InnerException is SocketException)
                    {
                        throw new InvalidConnectionException(_address.Uri, "Connection to RabbitMQ host failed", ex);
                    }
                }
            });
        }

        public void Dispose()
        {
            RemoveProducer();
        }

        void AddProducerBinding()
        {
            if (_producer != null)
                return;

            _producer = new ProducerBinding(_address, _bindToQueue, _publisherConfirmSettings);

            _connectionHandler.AddBinding(_producer);
        }

        void RemoveProducer()
        {
            if (_producer != null)
            {
                _connectionHandler.RemoveBinding(_producer);
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


There was a time in my home where a hot home cooked breakfast was only for special occasions like holidays or weekends. Then we went through a season where I made so many hot breakfasts that they all began to take it for granted. And now, we've found a happy medium.
I make hot breakfasts on special occasions and if you want it any other time, well, here's the ingredients. Have at it!
Now before you think I'm completely heartless, I made it as easy as I possibly can on them. I'm a firm believer in teaching my kids enough to work myself right out of a job so I've shown them how to make their own basic hot breakfast. Yes, even the seven year old can do it. I have a handy container full of homemade pancake mix at the ready for anyone who isn't happy with a piece of fresh fruit or a muffin from the freezer in the morning. On the outside of the container are all the directions they need to make themselves a pancake feast.
You know EXACTLY what's in it. Many convenience mixes have all kinds of preservatives and non-food items in it to keep it on the grocery shelf as long as possible. Yuck.
You're teaching your kids independence cuz let's face it, the goal is that they NOT live with you the rest of your life, right? Can I hear an Amen?
It's CRAZY cheap compared to the store bought mixes.
You are saving yourself from the nasty Mother's day breakfast that consists of a plate full of nameless items that you must choke down with a smile on your face. Now they'll know how to cook something for you that is actually edible.
So here is a recipe that you can make a store for up to 6 months in an air tight container.
In a bowl, combine ingredients. Label and store in an airtight container in a cool dry place for up to 6 months.
Stir In Options: chocolate chips, blueberries or other berries, mashed banana, 1/2 teaspoon orange extract or nuts.
LOVE homemade pancakes! You're so right, they ARE better!
This sounds like a great idea - and I can tell already the add-ins are going to get adventurous around my house, especially mornings I'm already at work!
Amen to choking down the Mother's Day breakfast!


text:
        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 2>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 2>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 2>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 3>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 3>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 3>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 4>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 4>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 4>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 5>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 5>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 5>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 6>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 6>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 6>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 7>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 7>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 7>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 8>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 8>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 8>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 9>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type , typename proto::result_of::child_c<TryCatch, 8>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch) , proto::child_c< 8>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 9>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type , typename proto::result_of::child_c<TryCatch, 8>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch) , proto::child_c< 8>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 9>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type , typename proto::result_of::child_c<TryCatch, 8>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch) , proto::child_c< 8>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, 10>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type , typename proto::result_of::child_c<TryCatch, 8>::type , typename proto::result_of::child_c<TryCatch, 9>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch) , proto::child_c< 8>(try_catch) , proto::child_c< 9>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };
        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, 10>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type , typename proto::result_of::child_c<TryCatch, 8>::type , typename proto::result_of::child_c<TryCatch, 9>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch) , proto::child_c< 8>(try_catch) , proto::child_c< 9>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };
        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, 10>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;
            typedef phoenix::expression::try_catch<
                typename proto::result_of::child_c<TryCatch, 0>::type , typename proto::result_of::child_c<TryCatch, 1>::type , typename proto::result_of::child_c<TryCatch, 2>::type , typename proto::result_of::child_c<TryCatch, 3>::type , typename proto::result_of::child_c<TryCatch, 4>::type , typename proto::result_of::child_c<TryCatch, 5>::type , typename proto::result_of::child_c<TryCatch, 6>::type , typename proto::result_of::child_c<TryCatch, 7>::type , typename proto::result_of::child_c<TryCatch, 8>::type , typename proto::result_of::child_c<TryCatch, 9>::type
              , catch_expr> gen_type;
            typedef typename gen_type::type type;
            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        proto::child_c< 0>(try_catch) , proto::child_c< 1>(try_catch) , proto::child_c< 2>(try_catch) , proto::child_c< 3>(try_catch) , proto::child_c< 4>(try_catch) , proto::child_c< 5>(try_catch) , proto::child_c< 6>(try_catch) , proto::child_c< 7>(try_catch) , proto::child_c< 8>(try_catch) , proto::child_c< 9>(try_catch)
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };


text:
Tag Archives: Arts and Crafts Movement
Fancy bricks
Posted by reggie unthank in Arts and Crafts, Decorative Arts
Arts and Crafts Movement, bricks, Cosseyware, Edward Boardman, George Skipper, Gothic revival, Norwich buildings
The look of a place
Until the coming of the railways in the mid C19th, towns were necessarily made from the materials around them. The honey-coloured villages of the Cotswolds look so right in their environment for even the stone roof-tiles topping the honey-coloured stone walls derive from the bedrock on which they stand. But as we know, Norwich is about as far from decent building stone as you can get. Only the Church and rich grandees could afford to import building stone by water; famously, the Normans built Norwich cathedral of stone shipped from Normandy. So between the age of the medieval timber-framed building and the arrival of steel-reinforced concrete the majority of the city's buildings were made from clay in the form of brick and tiles. This post focuses on decorative brickwork, produced by one family, that characterised Victorian building in Norwich.
Norwich roofscape from St Giles car park
Around 1860, Norfolk contained 114 brickyards spread throughout the county so though Norfolk may have lacked stone there was evidently no shortage of brick clay [1]. In the pre-railway age, bricks tended to be made close to the building site due to the difficulty of transporting heavy loads over long distances. The arrival of railways in Norwich in the 1840s allowed building materials, such as Welsh slate, to be transported more easily and this, combined with the repeal of the tax on bricks in 1850 [2], contributed to the explosion of terraced-house building in Norwich [3]. Surrounding Norwich were the brickyards of Banham, Lakenham, Reedham, Rockland St Mary, Surlingham and Welborne [1] but the one that perhaps had the greatest effect on Norwich via its red or white decorative products was the Costessey Brickyard five miles to the west, run by the Gunton family.
Gunton Brickyard, Costessey Nr Norwich. (c) Ordnance Survey 1882. Image source, Norfolk Heritage Centre
Many years ago I saw comedian Ken Dodd at the Theatre Royal Norwich. Part of his introductory schtick was to play with local names, pronouncing Happisburgh as Happy's berg instead of Hay's bruh and Costessey as three-syllabled Coss-tess-ee instead of Cossey. How we laughed. Anticipating Doddy's difficulties the Gunton family, who managed the Costessey Brickyard from the 1830s to 1915, called their range of ornamental bricks 'Cosseyware'. As the map shows, it was quite a large enterprise, employing 40 men and boys in 1882 [4].
(In an update) Costessey resident Peter Mann wrote in to say he was able to name all the workers at the Costessey brickyard (see footnote at end). Excitingly, he identified James Minns with son John Minns seated on his right. Both were labelled as "Carvers of Norwich", consistent with census returns giving their occupations as 'carver' (or, once for James, 'sculptor'). The entry for Minns on the Mapping of Sculpture website gives his full name as James Benjamin Shingles Minns (ca 1828-1904). James was sufficiently confident of his skill to submit (successfully) a carved wooden panel of 'A Happy Family' to the 1897 Summer Exhibition of the Royal Academy; he had also carved the mantelpiece and panelling for Thomas Jeckyll's commission for the Old Library at Carrow Abbey (1860-1). The presence of this highly skilled sculptor and his son at the Costessey Brickyard strongly suggests they were responsible for the ornate 'fancy' bricks and panels for which Guntons were locally renowned. From his independent status as 'Carver' it seems possible that "James Minns of Heigham" might have been freelance rather than a full-time employee, especially since his address was ca. five miles away from the Costessey Brickyard. [For more on Minns see the 'Angels in Tights' post].
Employees of the Guntons Brickyard Costessey. James Minns is arrowed (white) with his son John, arrowed red. Pre-1904. (c) Ernest Gage Collection at Costessey Town Council. The key to the workers can be seen in the footnote at the end.
Other yards made decorative bricks in Norfolk during the Victorian heyday but Costessey Brickyard became pre-eminent through its association with Costessey Hall. In 1824, when Sir George William Jerningham became the 7th Baronet Stafford, his "commanding and forceful"[4] wife became dissatisfied with the old Tudor hall at Costessey and so began an overambitious plan to build an elaborate, battlemented, pseudo-Tudor replacement. Designed by John Chessel Buckler, Costessey Hall was to be "the richest Gothic building in England" [quoted in 6] but it became a folly that was never fully completed [4]. The fortunes of the Guntons coincided with the rise and fall of the Hall.
Costessey Hall 1870, architect John Chessell Buckler. Source: RIBA Collections
Costessey Hall showing Tudor Revival chimneys made at the Gunton Brickyard. Source: Picture Norfolk and Museum of Norwich at the Bridewell
Gunton Bros catalogue 1907. Source: Norfolk Heritage Centre
In 1862, the owner of Costessey Hall, Sir Henry Valentine Stafford Jerningham, who had produced no heir, asked the wonderfully-named Masters of Lunacy to declare the next in line (his nephew The Right Hon. Augustus Frederick FitzHerbert Stafford Jerningham) to be of unsound mind [5]. When nephew Augustus inherited the estate in 1884 the Lunacy Commissioners suggested the Hall was not suitable for him and that it be closed up. But Norwich's foremost architect Edward Boardman argued against closure, marking an early connection between him and Costessey. On Augustus' death his brother, Sir FitzOsbert Edward Stafford Jerningham, inherited to become the last Baron Stafford to live at the Hall. He was described as an eccentric who, mindful of what had happened to his brother, kept his back to the wall (literally) and refused to leave the confines of the estate [4]. After his death the estate was seen as a white elephant to his inheritors, leading to the long drawn out demolition of the Hall.
Demolition of Costessey Hall began in 1920; seen here in 1934 (c) www.picture.norfolk.gov.uk
Tastes had already begun to change some years before the demolition of the Hall. During the second half of the C19th one of the styles within the all-embracing Arts and Crafts Movement was for decorative "Gothick" brickwork (usually red) of the kind that the Guntons had made first for Costessey Hall then for the wider public. However, this fascination for Tudorbethan brick was in decline by the turn of the C20th and in 1915 the Guntons failed to renew their lease at Costessey. All that remains of the Hall is the Belfry Block off the eighteenth fairway at Costessey Park Golf Club. And all that remains (reportedly) of the Brickyard is a derelict kiln at the end of Brickfield Loke.
The family continued making ordinary bricks (known as 'builders') at their Barney, Little Plumstead and Runton works but these outposts closed in 1939 due to fears that the kilns could act as beacons to enemy planes.
Stoking the furnace to burn bricks, probably at Gunton's yard at Barney. Source: Ernest Gage Collection at Costessey Town Council.
After the main phase of building the Hall, George Gunton began to look for alternative outlets for his decorative bricks; their widespread dispersal was greatly assisted by the 1850 repeal of the brick tax – a tax that had been particularly punitive for oversize decorative bricks [6]. Cosseyware began to increase in popularity, first under George Gunton then from 1868 under his sons William and George. It was therefore during the second half of the C19th that Costessey clay started to have an impact upon the appearance of the city.
At the back of the Old Red Lion Beerhouse at 64 Costessey West End, George Gunton built an outhouse. Local historian Paul Cooper told me: "The Red Lion outbuildings would have been a showroom and where they did the intricate carving on the chimneys and fireplaces."
Cosseyware letter bricks spell out the name of George Gunton. Bricks like these can be spotted throughout Norwich. Source: 'Picture Norfolk' and Museum of Norwich at the Bridewell.
The same gable end in 2016, minus doorways. Note the Cosseyware chimney.
Cosseyware chimneys in Costessey West End 2016. Left: grapevine pattern; right: 'patriotic' rose/shamrock/thistle bricks on the building shown in the previous image.
The GG tiles beneath the grapevine-patterned chimney on the left suggest this is one of the nine houses that George Gunton is known to have built between 1850-1860 [6] in West End, not far from the brickyard.
Letter and number bricks, identical to those at Costessey West End, on the gable end of a house at the junction of Belvoir and Earlham Roads, Norwich
Aucuba Villas (1896) on Earlham Road, Norwich. [Aucuba is an evergreen shrub]. Note the characteristic Gunton 'A' in all these examples.
... and again at Park Lane, Norwich
The rose bricks above the 'Adelaide Villa' lettering were still to be found in the Gunton Bros 1903 catalogue
The same bricks from the 'patriotic' range (but no leek!) were incorporated into many of the walls and features of the Plantation Garden, Norwich.
In the mid 1850s, Henry Trevor created The Plantation Garden near St John's Cathedral on Earlham Road in an old chalk and flint mine. It is a Victorian delight, benefitting from years of careful restoration. If you want to see a range of Gunton's products look no further: fragments from more than 15 of their 34 patterns on chimneys can be identified here [7].
The Plantation Garden's fountain (1857) with its characteristic mixture of flint and ornamental Cosseyware
Not far from the Plantation Garden this plaque can be found on Earlham Road near the junction with Park Lane.
Two of Norwich's foremost architects, Edward Boardman and George Skipper, used Cosseyware to ornament their buildings – a choice that helped define the appearance of the Victorian city. In 1869, Boardman designed the Princes Street Congregational Chapel (now United Reformed Church) and adjoining Church Rooms in an Italianate style.
Boardman's Congregational Chapel, with triangular pediment, is seen beyond the Church Rooms that he also designed. The Rooms have been renamed Boardman House and are now part of Norwich University of the Arts.
Gunton's white decorative wares were used to realise the classical Italian style
Pale brick from Gunton's was used again by Boardman for his office block, Castle Chambers, in Opie Street off Castle Meadow.
Castle Chambers 1877. Architect Edward Boardman
Some 20 years later Boardman was to design the Royal Hotel around the corner on Agricultural Hall Plain in red brick and ornamental Cosseyware. This hotel replaced the old Royal Hotel that provided the site for Skipper's Royal Arcade off the marketplace.
Royal Hotel, Norwich (1896-7). Architect Edward Boardman
The Arts and Crafts Movement roamed widely for its pre-industrial architectural influences: the Royal Hotel is described as being "free Flemish" [8]. The lower levels are relatively plain but further up the stylistic tics of neo-Renaissance architecture become more apparent in the ornamented string courses, gables and pinnacles – all richly decorated in Cosseyware.
The diamond shapes in the triangle at the centre of the gable above form a repetitive pattern or diaper that can be seen on several buildings around Norwich
The former carriage entrance of The Green House 42-46 Bethel Street offers a fine example of Gunton's diapering …
Boardman used red Cosseyware diapering on his own offices in Old Bank of England Court, Queen Street. His nameplate, which is a gem of Victorian lettering, was custom made rather then being made from Gunton's individual letter bricks.
Gunton's red clay was used to make these intricate tableaux on what were once George Skipper's offices, now subsumed into Jarrold's department store on London Street.
Arts and Crafts: Skipper is showing clients the Art of architecture while workmen demonstrate the various Crafts of building
In this other Cosseyware panel, Skipper introduces his work to potential clients. In the background are three of his completed Norwich buildings [9]. Now that we know what James Minns, the carver, looked like it is highly likely that top-hatted Skipper is pointing to a shield held by Minns who worked on several joint projects.
Glance right next time you exit Norwich Rail Station and you will see one of the most richly decorated buildings in Norwich – 22 Thorpe Road . It was designed ca. 1900 by A F Scott and Son [6] using red Cosseyware in Franco-Flemish neo-Renaissance style.
Bewick House, 22 Thorpe Road, headquarters of the Norfolk Wildlife Trust
The moulding is still crisp after more than 100 years
Buildings in the last quarter of the C19th buildings were often exuberantly marked with terracotta date plaques – perhaps an expression of the confidence felt by Victorian architects and their clients at the height of Empire. This example below is over one metre tall:
1878. Number 13 Ipswich Road
1875. Edward Boardman's office in Old Bank of England Court
1877. Boardman's Castle Chambers, Opie Street, Norwich
1894. Number 22 Thorpe Road
1886. Norwich Gaol, Mousehold Heath
1888. St Ethelbert's House, Tombland, Norwich
From terraced houses to large public buildings, Cosseyware left its distinctive mark on Victorian Norwich.
Lucas, Robin (1993). Brickmaking. In, An Historical Atlas of Norfolk. pp154-155.
Lucas, Robin (1997). The tax on bricks and tiles, 1784-1850: its application to the country at large and, in particular,to the county of Norfolk. Construction History vol 13, pp29-55.
O'Donoghue, Rosemary (2014). Norwich, an expanding city 1801-1900. Larks Press, Dereham.
Gage, Ernest G. (1991). Costessey Hall. A retrospect of the Jernegans, Jerninghams and Stafford Jerninghams of Costessey Hall, Norfolk. Available from: http://www.costesseybooks.co.uk/purchasebooks.htm
Gage, Ernest, G. (2013). Costessey: A Look into the Past. Pub: Brian Gage, 31 Eastern Ave, Norwich NR7 OUQ (also, see preceding link).
Lucas, Robin (1997). Neo-Gothic, Neo-Tudor, Neo-Renaissance: The Costessey Brickyard. The Victorian Society Journal pp 25-37.
Adam, Sheila (2009). The Plantation Garden Norwich: A History and Guide. (Available from the Plantation Garden, 4 Earlham Road, Norwich).
Pevsner, Nikolaus and Wilson, Bill (1997). The Buildings of England. Norfolk 1: Norwich and North-East. Yale University Press.
Bussey, David and Martin, Eleanor (2012). The Architects of Norwich. George Skipper, 1856-1948. The Norwich Society.
Visit: the excellent website with many photographs of Costessey Hall and of brick-making on: http://www.costesseybooks.co.uk/contact.htm. I am grateful to Brian Gage for generously providing information and access to the Ernest Gage Collection. Thanks are also due to Paul Cooper, local historian, for sharing his extensive knowledge of Costessey Hall and the Gunton Brickyard. I am grateful to Peter Mann for naming the Costessey workers.
Visit: www.picture.norfolk.gov.uk. An endlessly fascinating archive of photographs of old Norfolk with a great series of photographs of old Costessey Hall. Thanks to Clare Everitt, who runs the website, for her help.
Visit: if you haven't already seen the Plantation Garden you are in for a treat. Open daily 9.00am – dusk. Their excellent website is well worth exploring (http://plantationgarden.co.uk).
Footnote: Peter Mann mailed in to provide the names of men in the photograph of the Gunton workers. He says: "My Grandfather and Great Grandfather are included in the Picture. Names as follows:
Back Row L/R, Albert White, John Ireson, Charles Doggett, George Gunton (Part Owner), Walter Ireson, James Simmons.
Middle Row L/R, Daniel Drury, William Gunton Jnr, Fred Barber, William Gunton Snr (Part Owner), Noah Mansfield, H.E Gunton, Charles Gotts, Thomas Mann Jnr. Seated Row, Arthur Paul (kneeling), John Minns, James Minns, (Carvers Of Norwich), Joseph Goward, Thomas Mann Snr.
Bottom Row, Robert Burton, James Paul, William Bugdale, Harry Banham."
Arts & Crafts houses in Norfolk
Posted by reggie unthank in Decorative Arts
Arts and Crafts Movement, CFA Voysey, Edwin Lutyens, EW Godwin, Norman Shaw, Norwich buildings, Norwich houses, Queen Anne revival
Following the explosion of terraced-house building in the latter part of the C19th it was perhaps the Arts & Crafts movement that had the greatest influence on the detached and semi-detached houses that were then built at the edges of a still-expanding Norwich.
The Arts & Crafts Movement took its name from The Arts and Crafts Exhibition Society (1888). Its members believed in the fusion of art and craft and held to the principles of craftsmanship and truth to materials expounded by William Morris. Morris was revolted by Victorian mechanisation and started a moral crusade in search of a purer, craft-based way of living. His Red House, designed by his friend Philip Webb, represented a transition from full-blooded Gothic to a romanticised pre-industrial version.
The Red House, Bexleyheath. Built ca. 1860 (Ethan Doyle White)
Morris despised much of contemporary design so he decorated the house with help from friends such as the Pre-Raphaelite artists Rosetti and Burne-Jones. This was expressed in his famous motto: "Have nothing in your house that you do not know to be useful, or believe to be beautiful." At about this time Morris formed his own design company, Morris & Co, which became "the furnishing wing of the Pre-Raphaelite movement" [1].
William Morris' wallpaper design 'Fruit' (1864) still in production today (william-morris.co.uk)
Richard Norman Shaw was a contemporary of Webb's. Although both architects adhered to Morris' principles of locally sourced materials and craftsmanship both diverted from the Gothic to develop a vernacular alternative. Webb developed Old English design but by the 1870s this had given way to a trademark 'Queen Anne' Revival style [2]. This Arts & Crafts style was not a slavish return to the architecture from Queen Anne's age (early 1700s) but a mixture of influences: Dutch, Flemish, French, Robert Adam and the Japanese-influenced Aesthetic Movement. Added to this was an English Renaissance style based on Christopher Wren (the 'Wrenaissance') in which red brick was favoured over the white stone (or brick) of classical Palladian buildings [3]. As well as red brick, red tiles and terracotta panels became the materials of choice during the Queen Anne Revival.
A celebration of red brick, Ipswich Road 1878
In Shaw's version of Queen Anne, multi-paned windows with crisp white glazing bars were a distinguishing feature. By the time this had filtered down to the general building trade – which is when we see it in the provinces – a common formula for windows was for the small panes to be restricted to the upper part with larger panes of plate glass at the bottom [3].
'Queen Anne' in Unthank Road
Bedford Park Estate in Chiswick London occupies an important place in the Arts & Crafts canon because it provided the model for the late nineteenth century suburb and led to the Garden City Movement [1].
The Tabard in Bedford Park; a 'pioneer' Queen Anne pub designed in 1877 by R Norman Shaw. Courtesy architecture.com
Initially, EW Godwin – who anticipated modernism with his stunning Aesthetic, Japanese-influenced sideboard – had designed small detached and semi-detached houses but these were not well received and so Norman Shaw was recruited to provide further designs.
EW Godwin was heavily influenced by Japanese design as in this sideboard 1867-1880 (copyright Victorian and Albert Museum). A bit off-piste but a favourite of mine
The Ballad of Bedford Park (below), although satirical in intent, gives an idea of the totality of the Arts & Crafts movement and shows how its spirit invaded all parts of the art-conscious middle-class home.
With red and blue and sagest green
Were walls and dado dyed
Friezes of Morris there were seen
And oaken wainscot wide
Now he who loves aesthetic cheer
And does not mind the damp
May come and read Rosetti here
By a Japanese-y lamp.
(St James's Gazette, 1881)
Two other architects had a major influence on Arts and Crafts style. The first was Charles Francis Annesley Voysey [4]. Characteristically, he employed large sweeping roofs set above horizontal ribbons of windows. Walls were covered with his trademark white-painted roughcast. Even when he wanted to use local materials, clients insisted on his popular roughcast [5]. This coating, which John Betjeman [6] thought 'dematerialised' the surface of a house, provided local builders with an inexpensive shortcut to an Arts & Crafts style unburdened by any underlying philosophy.
Voysey designed this house for his father 1896. Photo FCG Dimmick (architecture.com)
Voysey took a child-like approach to his work and used obvious imagery like hearts as cuts outs on woodwork and as a recurring motif in his ironwork – another shorthand for readers of weekly trade journals like The Builder.
'Hearts of Oak' chair for Liberty with heart-shaped cutouts.
Edwin Lutyens was another key figure in the Arts & Crafts movement. He enjoyed a long professional partnership with the garden designer Gertrude Jekyll. In 1896 Lutyens built Munstead Wood. Miss Jekyll clearly wanted a house rooted in tradition ("Arts and Crafts simplicity was the note" [7]) for she specified something "designed and built in the thorough and honest spirit of the good work of old days" [8].
Munster Wood by Edwin Lutyens for Gertrude Jekyll (architecture.com)
His early designs involved huge chimneystacks in Norman Shaw's Old English style, horizontal bands of leaded casement windows, and great sweeping tiled roofs. These catslide roofs could come down to door level leaving the first floor bedrooms to protrude via large gables [1]. A Norfolk example can be seen at Overstrand Hall:
Lutyens' Overstrand Hall (overstrandparishcouncil.org.uk)
… and while we're in Overstrand here's a surprising Lutyens building:
Overstrand Methodist Church designed by Edwin Lutyens
Lutyens was famously playful and loved verbal as well as visual puns, such as shaping brackets to the silhouette of the client. In one version of a story he is claimed to have said to a bishop toying with a portion of fish, "I suppose that's the piece of cod that passeth all understanding."
George du Maurier, Punch (1895)
Although Arts & Crafts architecture became a popular movement its most iconic buildings were mainly architect-designed one-offs for the wealthy. Amongst the important examples in Norfolk is Home Place, now known as Voewood, at Kelling near Holt. Its architect was ES Prior, the co-founder of the Art Workers' Guild and "perhaps the most brilliant of all Shaw's pupils" [1]. Here he built a butterfly house with its obliquely projected wings. Building material dug from what is now the sunken garden was used to make the inner core of concrete to which the larger excavated flints were applied [7].
ES Prior's Home Place/Voewood with sunken garden at front. (voewood.com)
Two other butterfly houses are found in Norfolk: Kelling Hall by Sir Edward Maufe and Happisburgh Manor by Detmar Blow and Ernest Gimson. Although they were built in the Arts & Crafts spirit their singularity (and cost) ensured that butterfly houses did not become models for a more widespread Arts & Crafts style.
In Norwich, at number 24 Tombland is St Ethelberts designed by EP Willens and built in 1888. It throbs with A&C references: red brick, plaster swags between curved oriel windows, roughcast, dormers set in a tiled hipped roof. The design of this remarkable house is said [9] to owe a debt to Norman Shaw ("wildly Norman Shavian") but the original on which this was surely based is not too far to find.
St Ethelbert's No 24 Tombland, Norwich (1888)
The Ancient, or Sparrowe's, House Ipswich 1670 (Photo: Andrew Dunn)
'The Sparrowe's House' type of oriel (curved sides, flat front, leaded lights with a central arch) is recognised to be one of three Old English window designs used by Norman Shaw [3]. However, these two East Anglian buildings, with oriel windows joined by botanical swags, are so similar that it seems likely that the Norwich architect had first hand knowledge of the Ipswich building as well as of Norman Shaw's pattern book .
Swags are found on another Norwich building …
… St Mary's Croft in Chapelfield, built in the Tudor Revival style.
St Mary's Croft 1881
St Mary's Croft is a symphony of red brick, from the concave/convex ovals on the gateposts – a humorous example of the bricklayer's art – to the floral panels of moulded brick. I remember when it used to be my dentist's surgery.
One of my favourite buildings in Norwich is Tower House at the junction of Newmarket and Kingsley Roads.
Tower House, Kingsley Road, Norwich
Tower House is generically Arts & Crafts with roughcast walls and a romantic tower capped by an ogee lead roof. What I find more interesting is the simplicity and asymmetry of this elevation – its effect depending on the massing of ten different windows (plus fanlight) in eight different styles. This irregularity echoes one of the most iconic buildings of the Arts & Crafts movement: the White House by EW Godwin. The irregular composition of its windows – really a blocking out of shapes on a flat surface – is thought to reflect Godwin's fascination with Japanese art and the way it embraced asymmetry [3].
The White House in Tite St, Chelsea, designed by EW Godwin for James Whistler (1878). Demolished in the 1960s.
Below, in Limetree Road, Norwich is this archetypal Arts & Crafts house by Percy Morley Horder. (His students couldn't resist a Spoonerism and called him Holy Murder). He went on to design Nottingham University for Jesse Boot (the Chemist). This part of the building (1908) containing the carriage arch, covered in roughcast, is pure Voysey.
In 1879-1886, at the time of the first Ordnance Survey, the parts of Newmarket and 'Unthanks' Road south of the present Mile End ring road were mainly open fields and nurseries. Their development around 1900 shows how various Arts & Crafts features were absorbed by local builders to make the Edwardian house, some 40 years after Morris et al had tried to find an honest vernacular style.
These semi-detached houses on Eaton Road were designed by architects Postle and Webster in 1906 for the builders Podd and Fisher of Aylsham Road.
Eaton Road, Norwich
Constructed of red brick and tile the houses have Voyseyian touches: steeply-pitched roofs sometimes coming down to door level; roughcast for the upper floors; coloured glass hearts and heart-shaped cutouts in the woodwork.
This house on Unthank Road shows the now-familiar heart-shaped cutouts on an asymmetrical porch.
Below, the house on Grove Road is a good example of how Arts & Crafts design became part of the everyday vocabulary of the local building trade. A neighbour said that his grandfather ("Youngs the Builder") had built the house for his own family (presumably after the First World war).
Grove Road, Norwich
Handcrafted details include this decorative rainwater hopper
Davey, Peter (1995). Arts and Crafts Architecture. Phaidon Press, Oxford.
Anscombe, Isabelle (1991). Arts and Crafts Style. Phaidon Press, Oxford.
Girouard, Mark (1990). Sweetness and Light: The Queen Anne Movement 1860-1900. Yale University Press, New Haven and London.
Hitchmough, Wendy (1995). CFA Voysey. Phaidon Press, Oxford.
Blakesley, Rosalind P. (2006). The Arts and Crafts Movement. Phaeton Press, Oxford.
Betjeman, John (1974). A Pictorial History of English Architecture. Penguin Books.
Aslet, Clive (2011). The Arts & Crafts Country House. Arum Press, London.
Tinniswood, Adrian (1999). The Arts and Crafts House. Mitchell Beasley, London.
Pevsner, Nikolaus and Wilson, Bill. (1997). The Buildings of England. Norfolk 1: Norwich and North-East. Yale University Press, New Haven and London.
Thanks to David Bussey for background on the Eaton Road houses

redpajama_set_name: RedPajamaCommonCrawl


text:
Moving Day at the Hells Angels Clubhouse
13 Apr 19 FmH
After 50 years, Angels vacate notorious Greenwich Village headquarters brownstone for new digs in former Baptist church on Long Island.
'"The parties used to be great," Nancy said. "Until the explosion." In 1990, a garbage-can firecracker killed a fourteen-year-old boy. Over the years, the East Village Angels both caused and prevented mayhem. In 1994, the Times characterized this mayhem, part "lore and part police reports," as "countless decibel-cranking parties, LSD-laced misadventures, drug deals, orgies and random acts of violence against passers-by." In recent years, parking-space tussles resulted in beatings and a shooting; a woman who pounded on the door, screaming, was badly beaten. In 1978, the chapter president, Vincent (Big Vinny) Girolamo, of plaque fame, allegedly pushed his girlfriend off the roof, to her death. (He died, of stab wounds, before he could stand trial.) Innumerable bad vibes were doled out after unwanted bench-sitting, dog-peeing, and photography incidents. But, from the scuzz era to the N.Y.U.-and-condos era, club members also defended their neighbors; the Angels' block was considered the safest around.
"I haven't heard anybody say 'Good riddance,' " Janet said.
"I'll miss the way they decorated at Christmas," Nancy said.
"They used to break people's cameras," Janet said. In the Instagram age, unwanted photography had skyrocketed.…'
Via The New Yorker (thanks to Boing Boing)
Previous Post First black hole picture: The big mysteries we still need to solve
Next Post Raffi, the King of Children's Music, Takes on Trump
Paradoxical Undressing and Hide-and-Die Syndrome


text:
Chromium's seccomp Sandbox (26 Aug 2009)
I wrote an article for LWN about Chromium's seccomp sandbox. They decided that it wasn't in the right style for LWN, and they rewrote it to fit. Their version has just become available for free. I'm including my version below:
The Chromium seccomp sandbox
As part of the process of porting Chromium to Linux, we had to decide how to implement Chromium's sandbox on Linux.
The Chromium sandbox is an important part of keeping users safe. The web is a very complicated place these days and the code to parse and interpret it is large and on the front-line of security. We try to make sure that this code is free of security bugs, but history suggests that we can't be perfect. So, we plan for the case where someone has an exploit against our rendering code and run it in its own process with limited authority. It's the sandbox's job to limit that authority as much as possible.
Chromium renderers need very little authority. They need access to fontconfig to find fonts on the system and to open those font files. However, these can be handled as IPC requests to the browser process. They do not need access to the X server (which is why we don't have GTK widgets on web pages), nor should they be able to access DBus, which is increasingly powerful these days.
Drawing is handled using SysV shared memory (so that we can share memory directly with X). Everything else is either serialised over a socketpair or passed using a file descriptor to a tmpfs file. This means that we can deny filesystem access completely. The renderer requires no network access: the network stack is entirely within the browser process.
Traditional sandboxing schemes on Linux involve switching UIDs and using chroot. We'll be using some of those techniques too. But this text is about the most experimental part of our sandbox: the seccomp layer which my colleague Markus Gutschke has been writing.
The kernel provides a little known feature where by any process can enter 'seccomp mode'. Once enabled it cannot be disabled. Any process running in seccomp mode can only make four system calls: read, write, sigreturn and exit. Attempting any other system call will result in the immediate termination of the process.
This is quite desirable for preventing attacks. It removes network access, which is traditionally difficult to limit otherwise (although CLONE_NEWNET is might help here). It also limits access to new, possibly dangerous, system calls that we don't otherwise need like tee and vmsplice. Also, because read and write proceed at full speed, if we limit our use of other system calls, we can hope to have a minimal performance overhead.
But we do need to support some other system calls. Allocating memory is certainly very useful. The traditional way to support this would be to RPC to a trusted helper process which could validate and perform the needed actions. However, a different process cannot allocate memory on our behalf. In order to affect the address space of the sandboxed code, the trusted code would have to be inside the process!
So that's what we do: each untrusted thread has a trusted helper thread running in the same process. This certainly presents a fairly hostile environment for the trusted code to run in. For one, it can only trust its CPU registers - all memory must be assumed to be hostile. Since C code will spill to the stack when needed and may pass arguments on the stack, all the code for the trusted thread has to carefully written in assembly.
The trusted thread can receive requests to make system calls from the untrusted thread over a socket pair, validate the system call number and perform them on its behalf. We can stop the untrusted thread from breaking out by only using CPU registers and by refusing to let the untrusted code manipulate the VM in unsafe ways with mmap, mprotect etc.
That could work, if only the untrusted code would make RPCs rather than system calls. Our renderer code is very large however. We couldn't patch every call site and, even if we could, our upstream libraries don't want those patches. Alternatively, we could try and intercept at dynamic linking time, assuming that all the system calls are via glibc. Even if that were true, glibc's functions make system calls directly, so we would have to patch at the level of functions like printf rather than write.
This would seem to be a very tough problem, but keep in mind that if we miss a call site, it's not a security issue: the kernel will kill us. It's just a crash bug. So we could use a theoretically incorrect solution so long as it actually worked in practice. And this is what we do:
At startup we haven't processed any untrusted input, so we assume that the program is uncompromised. Now we can disassemble our own memory, find sites where we make system calls and patch them. Correctly parsing x86 machine code is very tough. Native Client uses a customised compiler which only generates a subset of x86 in order to do it. But we don't need a perfect disassembler so long as it works in practice for the code that we have. It turns out that a simple disassembler does the job perfectly well with only a very few corner cases.
Now that we have patched all the call sites to call our RPC wrapper, instead of the kernel, we are almost done. We have only to consider system calls which pass arguments in memory. Because the untrusted code can modify any memory that the trusted code can, the trusted code couldn't validate calls like open. It could verify the filename being requested but the untrusted code could change the filename before the kernel copied the string from user-space.
For these cases, we also have a single trusted process. This trusted process shares a couple of pages of memory with each of the trusted threads. When the trusted thread is asked to make a system call which it cannot safely validate, it forwards the call to the trusted process. Since the trusted process has a different address space, it can safely validate the arguments without interference. It then copies the validated arguments into the shared memory pages. These memory pages are writable by the trusted process, but read-only in the sandboxed process. Thus the untrusted code cannot modify them and the trusted code can safely make the system call using the validated, read-only arguments.
We also use this trick for system calls like mmap which don't take arguments in memory, but are complicated to verify. Recall that the trusted thread has to be hand written in assembly so we try to minimise the amount of this code where possible.
Once we have this scheme in place we can intercept, examine and deny any system calls. We start off denying everything and then, slowly, add system calls that we need. For each system call we need to consider the security implications it might have. Calls like getpid are easy, but what damage could one do with mmap/munmap? Well, the untrusted code could replace the code which the trusted threads are running for one! So, when a call might be dangerous we allow only a minimal, and carefully examimed, subset of flags which match the uses that we actually have in our code.
We'll be layering this sandbox with some more traditional UNIX sandboxing techniques in the final design. However, you can get a preview of the code in it's incomplete state already at its Google Code homepage.
There's still much work to be done. A given renderer could load a web page with an iframe to any domain. Those iframes are handled in the same renderer, thus a compromised renderer can ask the browser for any of the user's cookies. Microsoft research developed Gazelle, which has much stricter controls on a renderer, at the expense of web-compatibility. We know that users wont accept browsers that don't work with their favourite websites, but we are also very jealous of Gazelle's security properties so hopefully we can improve Chromium along those lines in the future.
Another weak spot are installed plugins. Plugin support on Linux is very new but on Windows, at least, we don't sandbox plugins. They don't expect to be sandboxed and we hurt web-compatibility (and break their auto-updating) if we limit them. That means that plugins are a vector for more serious attacks against web browsers. As ever, keep up to date with the latest security patches!


Crossfit is so much more than just throwing up a barbell. It's about moving well, maintaining flexibility and strength at every age, and making sure you don't get hurt! A couple weekends ago, our OCF coaching crew was invited to give a presentation about the many benefits of Crossfit no matter your current fitness level. Check it out!


text:
import sys
from pubnub import Pubnub

publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False

## -----------------------------------------------------------------------
## Initiate Pubnub State
## -----------------------------------------------------------------------
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
                secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on, auth_key="abcd")
channel = 'hello_world'

def callback(message):
    print(message)

print pubnub.revoke(channel_group='dev:abcd', auth_key="abcd")
print pubnub.audit(channel_group="dev:abcd")
print pubnub.grant(channel_group='dev:abcd', read=True, write=True, manage=True, auth_key="abcd")
print pubnub.channel_group_list_namespaces()
print pubnub.channel_group_list_groups(namespace='aaa')
print pubnub.channel_group_list_groups(namespace='foo')
print pubnub.channel_group_list_channels(channel_group='dev:abcd')
print pubnub.channel_group_add_channel(channel_group='dev:abcd', channel="hi")
print pubnub.channel_group_list_channels(channel_group='dev:abcd')
print pubnub.channel_group_remove_channel(channel_group='dev:abcd', channel="hi")
print pubnub.channel_group_list_channels(channel_group='dev:abcd')

pubnub.revoke(channel_group='dev:abcd', auth_key="abcd", callback=callback, error=callback)
pubnub.audit(channel_group="dev:abcd", callback=callback, error=callback)
pubnub.grant(channel_group='dev:abcd', read=True, write=True, manage=True, auth_key="abcd", callback=callback, error=callback)
pubnub.channel_group_list_namespaces(callback=callback, error=callback)
pubnub.channel_group_list_groups(namespace='aaa', callback=callback, error=callback)
pubnub.channel_group_list_groups(namespace='foo', callback=callback, error=callback)
pubnub.channel_group_list_channels(channel_group='dev:abcd', callback=callback, error=callback)
pubnub.channel_group_add_channel(channel_group='dev:abcd', channel="hi", callback=callback, error=callback)
pubnub.channel_group_list_channels(channel_group='dev:abcd', callback=callback, error=callback)
pubnub.channel_group_remove_channel(channel_group='dev:abcd', channel="hi", callback=callback, error=callback)
pubnub.channel_group_list_channels(channel_group='dev:abcd', callback=callback, error=callback)


Webcam Erin, New York, USA - 17.4 miles from Smithboro: South Erin Weather - A webcam in Erin, New York with image archive, weather data and timelapse videos.
Webcam Endicott, New York, USA - 18.5 miles from Smithboro: West Corners WeatherCam - A webcam in Endicott, New York with image archive, weather data and timelapse videos.
Webcam Binghamton, New York, USA - 25.1 miles from Smithboro: Weathercam - A webcam in Binghamton, New York with image archive, weather data and timelapse videos.
Webcam Dryden, New York, USA - 32 miles from Smithboro: Weathercam - A webcam in Dryden, New York with image archive, weather data and timelapse videos.
Webcam Tunkhannock, Pennsylvania, USA - 41.4 miles from Smithboro: Tunkhannock High School - A webcam in Tunkhannock, Pennsylvania - camera location: Tunkhannock High School.
Webcam Dallas, Pennsylvania, USA - 53.3 miles from Smithboro: Misericordia University - A webcam in Dallas, Pennsylvania - camera location: Misericordia University.
Webcam Forest City, Pennsylvania, USA - 54.8 miles from Smithboro: Forest City Regional Jr Sr High School - A webcam in Forest City, Pennsylvania - camera location: Forest City Regional Jr Sr High School.
Webcam Dunmore, Pennsylvania, USA - 58 miles from Smithboro: Dunmore Corners Live - A view of the main intersection in Dunmore, Pa. It is where North and South Blakely St meets East and West Drinker St.
Webcam Wilkes-Barre, Pennsylvania, USA - 60.7 miles from Smithboro: Heights Murray Elementary School - A webcam in Wilkes-Barre, Pennsylvania - camera location: Heights Murray Elementary School.
Webcam Wilkes-Barre, Pennsylvania, USA - 60.7 miles from Smithboro: Mohegan Sun - A webcam in Wilkes-Barre, Pennsylvania - camera location: Mohegan Sun.


text:
Port 1995 Taylor
Taylor, Fladgate & Yeatman
Quinta de Vargellas, Magnum, Bottled 1997
Provenance: Sylvies, 1/29/2016
1.5 ltr
Fill level
Base neck
Since 1692 making the history of Port Wine. Port is one of the great classic European wines, and its history is a long and fascinating one, Taylor's is one of the oldest and most famous producers. Since its foundation in 1692 by Job Bearsley, the company has remained independent.
Now well into its fourth century, it has thrived and prospered, establishing itself as one of the world's most respected historical wine houses — an achievement through the perseverance, pioneering spirit and continuity of purpose of successive generations of family involvement.
Bearsley Years
The story begins in 1692 with the arrival in Portugal of an English merchant called Job Bearsley, although it would be many years and owners before it came to be known as Taylor's. Bearsley initially traded in red Portuguese wine from the northwest of the country, and in 1744, under his grandson Bartholomew, the company became the first British wine merchant to buy a property in the Douro.
Yeatman
Taylor's changed hands often during the 19th and 20th centuries, coming under the control of both Joseph Taylor and John Fladgate, who gave the company its name. Taylor's survived a rebuild after phylloxera hit at the end of the 19th Century and the two World Wars. It came to the Yeatman family at the beginning of the 20th Century, and they have been the proprietors since.
Originator of Late Bottled Vintage
Taylor's is respected as a producer of wood aged ports and holds one of the largest reserves of rare cask-aged wines from which they originate its distinguished aged tawny Ports. The house is also known as the originator of Late Bottled Vintage, a style which the firm pioneered and of which it remains the leading producer.
Only Port
Unlike many other houses, which include a range of dry red wines in their portfolios, Taylor's only makes Port. The collection consists of a series of a bottle- and wood-aged Ports including vintage, LBV, single-harvest, single-estate, and white Port.


text:
Home » News » Financial Rewards to Stop Smoking Works Well among Poor Pregnant Women
Financial Rewards to Stop Smoking Works Well among Poor Pregnant Women
Smoking during pregnancy increases the risk of harm to both the mother and child with the behavior claiming the distinction as the number one cause of poor pregnancy outcomes.
Emerging studies also suggest in-utero smoke exposure can harm the child by increasing the risk of respiratory and cardiac illnesses later in life.
The good news is that the prevalence of smoking during pregnancy has decreased. The bad news is that economically disadvantaged pregnant women continue to smoke at much higher rates than affluent women.
For the last three decades, developing more effective smoking cessation interventions for pregnant women — especially among vulnerable populations — has been a public health priority.
While the challenge is ever present, one strategy stands out as being the most efficacious and cost-effective, explains Stephen T. Higgins, Ph.D., director of the Vermont Center on Behavior and Health.
Higgins discovered financial incentives in the form of vouchers exchangeable for retail goods, like groceries and diapers, work wonders in getting moms to stop smoking.
During the U.S. cocaine epidemic of the 1980s and 1990s, when virtually all other treatments were failing miserably, Higgins initiated the use of monetary incentives along with intensive counseling to change behavior.
The treatment approach became known as contingency management in the substance abuse field.
The approach, he explains, has been repeatedly shown to aid smoking cessation among pregnant and post-partum women, especially those who are economically disadvantaged.
Higgins says this strategy is especially important for "those who work with this population and need to be aware of alternatives to the status quo."
In addition to his own research findings, Higgins analyzed other randomized controlled trials between 2012-2015 that used financial incentives to help pregnant smokers quit.
The findings from his research now appear in an article, "Some Recent Developments on Financial Incentives for Smoking Cessation Among Pregnant and Newly Postpartum Women" which appears in the journal Current Addiction Research.
Source: University of Vermont College of Medicine/EurekAlert
Nauert PhD, R. (2018). Financial Rewards to Stop Smoking Works Well among Poor Pregnant Women. Psych Central. Retrieved on January 29, 2020, from https://psychcentral.com/news/2016/04/06/financial-rewards-to-stop-smoking-works-well-among-poor-pregnant-women/101415.html
Last updated: 8 Aug 2018 (Originally: 6 Apr 2016)
Why Should I Quit? Why is It Difficult? Second & Third-hand Smoke Preparing to Quit Medications Your Quit Smoking Day Managing Cravings If You Slip Sticking With It