in reply to Re: Re: Re: Re: Code Critique
in thread Code Critique

Agreed on every point! ;-).

Maverick, since you've had earlier experience integrating a templating mechanism into your perl code (the backend for the site you've worked on), I'd like to repean an earlier question that I had. Did you have any difficulty integrating the templates? How did you overcome them? I'm really interested in knowing how you structured your display data so that it could be included within a template in any way the UI guy wanted to? Say, I had seen some complex templates with quite a bit of templating code.. how much of that did you have in your site?

"There is no system but GNU, and Linux is one of its kernels." -- Confession of Faith

Replies are listed 'Best First'.
Re (tilly) 6: Code Critique
by tilly (Archbishop) on Jan 02, 2002 at 10:36 UTC
    Excellent questions.

    It is unfortunate that people tend to avoid answering this kind of question. The reason is that there are not simple good answers. But saying nothing can make pro-template people look a little religious. Templating is great for all of these reasons! Good luck getting any concrete advice on doing it though.

    The short answer is that templating is just a form of modularizing, and so you approach it like you would any other modularization. Define your division of labour into components. Define your interfaces. Then stick to them.

    Unfortunately that glib answer, while correct, is seriously misleading.

    Yes, templating is just another form of modularization. Modularization should, of course, be the bread and butter of any decent programmer. You should spend your days breaking problems up into components, defining interfaces to each component, then putting them together into programs. As is pointed out above, modularization with templating techniques is good for the various reasons that modularization is always good. It is a natural opportunity for modularizing because it allows you to divide tasks naturally along lines where the kinds of knowledge which are needed are very different. But it is unfortunately a hard place to modularize for many good reasons:

    1. We aren't as good at modularization as we could be.

      While modularization is good, in practice most programmers are somewhat inconsistent in doing it. We violate encapsulation, set up poorly chosen interfaces, don't get time to think about design, or may not even realize how much we don't understand program design. For most problems we can do all of this and mull through. But it means that when we need to modularize, the mental muscles you need to think through issues are not as well worked as you want them to be.

    2. It is also a language boundary.

      Modularizing is easier when both sides are the same language because interaction between them is more straightforward, and is likely to be the same on both sides. But in this case you are crossing a language boundary, and so interaction mechanics are different on each side. Plus the people on different sides are likely to be using radically different toolkits, making the difference even sharper. One set of interfaces just became two sets, that don't know how to talk directly. There are solutions, but what they are depend on your templating tool.

    3. There are different people on each side.

      It always complicates interactions hugely when you add to the mix the need for people with different ideas to cooperate.

    4. The two sides have different skillsets.

      When people with similar skills cooperate, they may disagree but it is at least relatively easy for one to explain the concerns they have to the other - the other has an experience base where they are likely to understand and figure out where to give and take. They might even offer good suggestions. Cooperating across a lack of common ground makes it harder to resolve issues.

    5. The other side is likely to have much less experience with modularization.

      As a programmer you are likely to think about modularization. In a lot of ways it is a big part of the mental toolkit through which you earn your bread and butter. The same is less likely to be true of the kind of graphics person who you may wind up interacting with on the other side. They learn how to use tools, how to achieve effects, and about how those effects affect people's reactions. They have less practice with, for instance, techniques for keeping changes synchronized across multiple places.

    That is quite a list of problems. And there isn't a single solution that I know of. Rather there are hard decisions, and how you need to make them depends on what you are doing. There are a range of solutions from generating HTML in code (eg CGI's autogeneration methods - easy for the programmer but makes it impossible for anyone who is not a programmer to work with it) to having the UI people using Dreamweaver with predefined components, some of which happen to be parametrized with callbacks to data sources programmers need to supply. I have used quite a few different solutions on this spectrum, and I strongly suspect that for any possibility I could find a situation in which I would choose to use it.

    But there are some principles that I think can guide people in figuring out how to handle this problem.

    • Pay attention to the trade-offs.

      When there isn't a general solution you can recommend pretty much across the board (I think there isn't), there usually are important trade-offs that need to be kept in mind. Templating is no exception. Templating is a level of indirection and complicates life for one or both (probably both) parties. You want the two to be able to work relatively independently with a minimum of getting in each other's way. There is, however, going to be set-up effort, limitations in how each side can work, and the infrastructure involves up front complications. What level of effort is acceptable depends on how complex the end task is, where the complexity is, what kinds of change requests are expected, and so on. Virtually the only choice you don't have here is whether you want to make them. You will need to make them.

    • Someone needs authority to make it work.

      Many of the issues I pointed out involve the need for cooperation between people with different needs and backgrounds. Unless someone is ready to say, No, you must play by the rules. it is guaranteed that people working at cross-purposes will accidentally undermine the necessary infrastructure. And the result will be a Big Ball of Mud.

    • The UI people need to be component aware.

      You asked how you structure things so that the data can go in in any way the UI person wants. Wrong question. In order to cooperate both sides must meet in the middle. Components that have programmatic data inputs take programmer effort to produce and customize. While the UI person may be able to place them, adjust various parameters in them (eg data source, colors, borders, etc), there will be inevitable limits. The programmers can offer black box components, and can work with the UI people to make sure that appropriate components are available, but components need to remain black if separation is to be maintained. (It is going, of course, to be much easier for everyone if the tools that the UI people use can be taught to understand the components which are available and work directly with them.)

    • There needs to be a clear division of types of control.

      If you are going to create a division of content and presentation, each type of thing needs to clearly fall on one side or the other. Look at this site for instance. Navigation is clearly controlled programmatically. Layout of nodelets likewise. UI people can create images, create new themes, create layout for new nodelets etc. But you could not just create a few new pages in Dreamweaver with a custom look and feel, drop them into the site, and have things go smoothly.

      That is a reasonable choice for a simple content-driven site. If you had more types of pages to offer and the content was less important, then you might want to let the UI people control overall layout much more freely. Whatever choice you make, initial choices here are going to drive the kinds of interfaces each side has to live with, which is going to decide what kinds of restrictions each lives with.

    • Keep your interface clean.

      As stated in my glib answer, this is fundamentally a modularization problem, and the answer is to proceed as you always do with modularization - define a division, define an interface across that division, and program to that interface. That is still, despite all of the additional problems and complications, fundamentally correct. And the key, as always with modularization, lies in defining a clean interface. The additional issues make that harder, which means keeping that in mind becomes more important, not less.

    A bit late, a lot long, but hopefully this answer will be helpful whenever you try to use templating. (I fear it will be most useful when you are trying to figure out why your first attempt didn't turn out as well as you wanted. But that helps your second attempt, so that is officially OK.)