There are several problems with constraints I'll walk through below. The goal is to design a shape like a slice of bread. Essentially, it's a rectangle with rounded corners in which the top side is replaced by an arc. Here are the first three sides:
So far, so good. It's left/right symmetric, so I've added those constraints as well as tangent constraints so the arcs are smooth. At this point, moving the various points mostly behaves as expected. One that's a little strange is the arc center. When it's moved, the vertical lines can move wildly. While that's 'correct' to remain tangential to the arcs, that's Bug 1: The amount of movement is unexpected and can be difficult to control. The software should constrain change so that large changes require larger mouse movements. The amount of change should remain proportional to the amount of user's input movement.
Completing the shape, we have:
Here, the last tangential constraints have not been added. But even at this point, the sketch is becoming harder to control. Moving the left line too far to the right leads to this:
This is unexpected! It's hard to imagine wanting such an inversion of the edge relationships just to make the constraints work. If I wanted such a configuration, I would have started there. I wouldn't have started as above, then pushed the lines around to get that shape. So it's a surprise, an expected one, and an unwanted one. I have to call that a bug. Bug 2: The arrangements of the lines shouldn't change radically to meet constraints. As before, the software should make the user do more input to push it into a radical change. It shouldn't happen easily as I move an edge around.
Undoing that and adding the remaining constraints, we have:
Looks good. The right line/upper right arc joint doesn't need a tangential constraint due to symmetry. So now I just want to be able to move the parts around to finalize the shape. But that's hard! Moving the points, arcs, or lines leads to radical, unexpected, and unwanted results.
Here's one:
This image wasn't produced by making a strange series of moves. It was produced in one motion from the above sketch!
Here's another:
Again, these images illustrate the crazy jumps the software can go to just by moving one point or edge. These are more examples of Bug 2 above, unexpected, radical configuration changes from small mouse movements. In addition, they've destroyed the drawing. Bug 3: Insane constraint solutions should never be shown.
Another phenomenon is that the the motion is uneven and unexpected for individual points or edges. Some points don't move at all if you drag them. Others make large, unexpected changes to the overall shape instead of just moving the part grabbed. Bug 4: Edges and points should be moveable as expected. It should not be the case that some lock, some move reasonably, and others make large changes to many other edges.
For example, when I grab the center point of the upper left arc, I expect that moving it will shrink the arc's radius. Instead, the whole corner moves, or it blows up.
Bug 5: Moving an edge to the left should not also shrink and rotate it suddenly as well. Changes due to constraint requirements should be smooth and gradual. The user should see what effects their inputs are having so they can adjust their input.
Also, when you drag into a strange state, you can't just drag back out of it. Further dragging just makes more of a mess and you have to hit 'Undo.' Bug 6: It should not be possible to drag into a configuration you cannot undo by dragging back the way you came.
There may be better, easier ways to make this shape. Indeed, in actually working with this design, I found that using the Fix/Unfix constraint to prevent points from moving was key to being able to maintain control while making adjustments. But that shouldn't be necessary.
The point is not that this is a hard set of constraints to meet. The point here is that the software does a lot of unexpected, unwanted, and radical changes with this configuration of constraints and edges. Even for, or especially for, sketches with unusual constraints, the software should behave in smooth, reasonable, and unsurprising ways.
File here: http://a360.co/2az0SIb
