Hot new service – Ultra SEO Solutions review

I didn't see the companies presence on this website but I thought I would share my good experience.

I bought 500 dofollow blog comments for unique domains and within 24 hours…. guess what it was fulfilled and with an extra 50! It was pretty awesome and did have an effect on my SERPS

I'm not an affiliate or anything like that but thought you guys should know.

How to make reviewers in Stack Exchange’s low-quality review realise the consequences of choosing a canned comment?


How can the interface for choosing canned comments when opting to delete in Stack Exchange’s low-quality queue be improved to make reviewers more aware of the actual effects of their choice.

Current situation

The current interface faced by reviewers who opt to delete a post in the low-quality queue on Stack Exchange is this:

  1. They are shown the post and then can make their actual choice, i.e., whether they want it to be deleted, want to edit it, etc:

    main interface of the low-quality queue

  2. Reviewers who opt to delete, are presented with a choice of canned comments to be left on the post on their behalf:

    selection of canned comments in the low-quality queue

The problem

Many reviewers never or almost never choose the no comment needed option, even though there already is a comment expressing the same thing on the post (thus making the new comment redundant) or none of the comments applies. Please assume this problem as given for the purpose of this question. If you want to debate this, here is a question on Meta SE where it would probably be well placed.

As far as I can tell, the reason for this is a mix of:

  • A variation of banner blindness that makes reviewers never (re)read the header of the canned-comment dialogue.

  • Users think that their choice in the canned-comment dialogue does more than just leaving a comment such as contributing to some statistics or affecting what happens to the post (e.g., this is a commentary actually effecting comment conversion).

  • Users think that no comment needed is not the right thing to do and may be held against them. (This is is not completely unjustified, because it is actually true, when one of the canned comments is spot-on and there is no equivalent comment yet.)

  • The interface focusses on the reason for deletion (e.g., “This is a ‘thank you’ comment.”), not on the comment that is actually chosen.

My question

How could the interface be improved such that it is more clear that the canned comments are just canned comments and that leaving no comment can be a valid choice?

What I considered so far

The following options do not convince me though at least the first one would be better than nothing:

  • One could add more explanation to the no comment needed option such as a text explaining that “This is a good choice if an existing comment already addresses the post’s issues.” However, I fear that this may be affected by the same banner blindness and will be ignored.

  • One could add another level of dialogue: After opting for deletion, users will be presented with a dialogue that allows them only to choose between no comment, canned comment, and possibly custom comment (explaining these choices) and only presents them with a selection of canned comments if they choose canned comment. The disadvantage of this is that it is yet another layer of dialogue and it is not clear what the choices of canned comments are in the first layer.

  • Remove the bold headings displaying the reason for deletion (e.g., “This is a ‘thank you’ comment.”). This should considerably increase the effort for finding the right comment, when one is appropriate.

Design Review Of SOLID Principles For An Autonomous Mobile Robot

I am self-learning robotics, C++ and good object oriented design. I have asked various questions over the past couple of weeks: 1 and 2 that have lead to the following design.

The design goal is for portability. It is a Go-To-Goal Differential Drive Robot with PID to regulate the behavior.

I am hoping my design is robust enough so that once I have more understanding of dynamic vehicle models, that I can simply plug those in without modifications ; the O in SOLID 🙂

please note I have not compiled this code yet, I am not looking for a syntax check, just rough design review

The state of the robot is represented as follow:

struct SensorConfig {   // required config values };  class Sensor {    public:   virtual ~Sensor() = default;    // basic checks to ensure sensor is still   // functioning correctly   virtual bool IsActive() = 0;    //    virtual void Init(const SensorConfig& config) = 0;     virtual vector<double> const ReadMeasurement() = 0;   };  class State {   public:    virtual ~State() = default;    virtual void Update(const vector<double> values) = 0;   virtual void Update(const vector<Sensor>& sensors) = 0;    // overloading the operator so that I can measure   // the error between target state and current state   // each model can have its own way of deciding how to do that   virtual vector<double> operator- const (const State& state) = 0;  };  class UnicycleModel : public State {   public:   UnicyleModel(double velocity, double omega, double wheel_radius, double distance_between_wheels);    virtual void Update(vector<Sensor>& sensors)   {     if (sensors.size() < 2)       {     // FAIL with error message       }     Sensor r_wheel_odometry =;     Sensor l_wheel_odometry =;      double r_rotation_rate = r_wheel_odometry.ReadMeasurement().at(0);     double l_rotation_rate = r_wheel_odometry.ReadMeasurement().at(0);      // apply unicyle model equations to     // set velocity_ and omega_;    };    // just an example   virtual vector<double> operator- const (const State& state)   {     // example     return vector{ - this->omega_, state.velocity - this->velocity};   }   private:   double velocity_;   double omega_;   double wheel_radius;   double distance_between_wheels_;   };  class LongitudinalDynamicsModel : public State {    public:   LongitudinalDynamicsModel(double velocity, double theta, double phi, // etc);    virtual void Update(vector<Sensor>& sensors)   {      // apply vehicle dynamics equations to     // set state;    };    virtual vector<double> operator- const (const State& state)   {     // example     return vector{state.velocity - this->velocity, //etc};   }  private:   // state representation };  class LatDynamicsModel : public State {    public:   LatDynamicsModel(double velocity, double theta, double phi, // etc);    virtual void Update(vector<Sensor>& sensors)   {      // apply vehicle dynamics equations to     // set state;    };    virtual vector<double> operator- const (const State& state)   {     // example     return vector{state.velocity - this->velocity, //etc};   }  private:   // state representation }; 

The go-to-goal behavior is represented as

class PID {   public:   virtual ~PID() = default;    virtual State const CalculateError(const State& target_state, const State& current_state) = 0;    virtual void SetProportionalGain(const double& kp) = 0;   virtual void SetIntegralGain(const double& ki) = 0;   virtual void SetDifferentialGain(const double& kd) = 0;  };  class Actuator {   public:   virtual ~Actuator() = default;    virtual bool Apply(const State& error) = 0; };  class Motor {  pubic:   Motor(Pwm speed_pin, Ouput control_a, Output control_b);    inline bool Start();   inline bool Stop();   inline bool SpinForward();   inline bool SpinBackward();  };  class UniCycleDriver : public Actuator {   public:   UniCycleDriver(Motor& right_motor, Motor& left_motor);    virtual bool Apply(const State& error) {    };    inline bool Start();   inline bool Stop();   inline bool DriveForward();   inline bool DriveBackward();    inline const bool IsDrivnigForward();   private:   bool is_driving_forward_;   Motor right_motor_;   Motor left_motor_;  };  class FrontWheelDriver : public Actuator {    public:    virtual bool Apply(const State& error) {    };  }; 

Then finally, the main part of the system, where the control loops will take place

// this class should be instantiated in main along with calls to factories required to instantiate the sensors, states, etc.. class ControlAgent {    // set target state   // measure current state   // calculate error   // apply error   public:   ControlAgent(const vector<Sensor>& sensors,            PID& regulator,            Actuator& actuator);    void SetTargetState(const State& state);    void ClosedLoop()   {     State error = regulator.CalculateError(target_state_, current_state_);      while (target - error > some_threshold)       {     actuator.Apply(error);     current_state_.Update(sensor);     error = regulator.CalculateError(target_state_, current_state_);           }   };  private:   State current_state_;   State target_state_;  };