Recently I started to get spammed by comments for this blog. So I went ahead and installed captcha support for comments and contact. I used http://dbvt.com/blog/archive/2006/03/29/4222.aspx mod. It's quite nice and complete, but it did require me to download CommunityServer source, update it and recompile to support the new feature.

Thanks to Dave Burke for the nice mod and easy to follow instructions.

I haven't written here for quite a while and I would like to attempt to fix that today. Last time I talked about what design is. Today I want to continue talking about design.

Recently my girlfriend has exposed me to the beading (Beaded Flora is her blog on the subject). She uses beads to create complex, but beautiful flowers and animal figures. When I learned more about beading it reminded me about development and design, and I thought it would be interesting to write about it.

At an abstract level beading deals with basic building blocks, beads and a thread of wire. There is also a simple set of rules and constraints (describing how the wire can be bent before it breaks, how different colored beads can be combined, etc.) From the above techniques and patterns emerge. To create a net or a sphere with a wire one needs to follow steps described by a technique. Those shapes are combined to have a figure.

As you can see beading is quite algorithmic. Creativity is used to come up with new techniques (this is really hard and time consuming) or figuring out what shapes are required to create a flower and what techniques could be used to create each shape. This is a simplified example of software development. It demonstrates well though how to tackle complexity of the problem solving.

It's impossible to create the whole flower as a single solid figure (or rather it's very hard). Instead a beading artist beads each part of the figure separately. When all components are ready they are combined together. This is one of the widely used (often intuitively) approaches in design. How do we design and develop a really complex program? We can start by separating the program into logical parts, developing each part individually and then connecting them all together. This is already used widely.

The problem is how to split the project up. With a flower it is easy to see all parts it is made up from (leaves, petals, flower bud, etc.), but doing it to a program is not quite so simple. It's much easier to split a flower up over a program because flower is a physical object that we can see. Program at first is too abstract for our brains. We need to give it a shape, a form. Diagrams are often used for that (UML for example). We could write out the program description and try to derive it's components from it. This is partially why design is a creative process. Now I want to try and get something useful out of the analogy between beading (and it's design) and development (and it's design), and design process in general.

In beading, there are tight restrictions on what can be done. There's only a single thread of wire and it can be bent only so much before it breaks. Building blocks are very simple (wire and beads). This dictates how to separate the figure into sub-parts and how to connect all sub-parts together. Maybe if we can describe (or even create) certain constraints we can make our job much easier. Too many constraints, however, can make the problem even harder (so common sense should be used). We could try changing constraints, make them tighter and loser to see what kind of design we will get as a result. It would be wise to make the whole process dynamic and experiment with different attributes, but that's a subject for a different post. It's possible to use sliders tool to do show a list of constraints and try to come up with different constraint combinations. For example we could create artificial constraint of a class having a limited number of visible members. What if the limit is 2, 5, 10, 50? We need to have a good way to come up with design quickly. Drawing diagrams could come in handy.

Another interesting thought just crossed my mind. To tackle combination of constraints we could design for each constraint separately, loosening the rest. This could make it easier to come up with required design that takes into account everything. For example, we need to design a user interface that has to be simple to use and easy to learn, complex enough to work on a specific problem, and compact (in number of controls). First step could be to design an interface to be simple and easy to learn, then design it to help with specific task as best as possible, and then create a compact interface. When we have all three versions it could be much easier to come up with a general interface to take into account all three requirements.

I also want to point out that design tries to approximate perfect solution. There is a large set of possible designs with different constraints, and we, as developers and designers need to choose the best approximation of the perfect solution (if discovering perfect solution is impossible at the time, and it usually is due to time constraints and unknown factors).