Concept Discussion: Types and Attributes

Imagine, we have a software that lets you manage a zoo.

The designers of this software are having a “design” discussion:

-They all agree that the system should be capable to assign a type to each animal. The software will ship a hierarchy of out-of-the-box types. Users shall be able to extend this hierarchy to create their own types.

-They also agree that each animal should have a set of related attributes such as the sex, weight, healthiness, tiredness. The value of some of these attributes may change or be changed over time. When the user selects an animal all current values are presented so the user can get an overview about the current state of the animal.

-The current discussion is whether the set of related attributes should directly depend on the type of an animal or whether they should add another concept called Animal Description. The zoo manager could then define several animal descriptions, and assign them to individual animals, independent of their class. The concept of Animal Descriptions came up because they assumed that it would be too much effort to define to the set of relevant attributes for each individual animal.

-Steven is in favour of Animal Descriptions. He has read an interesting book about software concept and has learned to avoid overloaded and redundant concepts. He argues that Animal Type is a concept that mainly serves the purpose to classify animals according to a familiar taxonomy in order to search and filter for certain types.
The Animal Description concept, he argues, serves the purpose of defining the relevant information that should be displayed when user wants to be informed about a certain animal. Degining a set of attributes would overload the concept Animal Type. In many cases not all relevant attributes depend on the Animal Type. For instance a pregnant animal has special attributes of interest - or an animal born in the wild, or an animal that is part of a research project.

-Francis argues that the introduction of Animal Descriptions makes the software hard to understand. The user could always define a new type together with its set of attributes.

-Steven argues that in this case, the users would have to artificially extend the type hierarchy, leading to a degration of the original Animal Type concept.

-Francis also argues that search & filter are more general concepts not directly bound to types. Today, they may use animal types as criteria, but further criteria could be added. He also argues that there are some users for which the relevant attributes always depend on the type - a kind of simple use case.

-now Steven is unsure how to proceed. He still thinks that both should be separate concepts. Maybe the purpose of Animal Types is just to allow users classify animals in their prefered way. The point is that the relevant attributes may not directly depend on this classification. He is also unsure whether these concepts are even concepts in the sense of the book he has read, they do not seem to involve state and behavior but are rather concepts from the domain of conceptual modeling.

It seems like there is a trade off between optimization for simple use cases and optimization for complex use cases. If the use case is simple Animal Descriptions are redundant, if the use case is complex their absence leads to overloading of Animal Types.

Do you have any advise? Do you think that the alternatives are related to software concepts in the narrow sense discussed in this forum?

1 Like

Hi Fabian, Welcome to the forum!

I’m curious to understand better what you have in mind for the AnimalType and AnimalDescription concepts. I think I’m with Steven, who says he is

unsure whether these concepts are even concepts in the sense of the book he has read, they do not seem to involve state and behavior but are rather concepts from the domain of conceptual modeling.

I see potentially three different concepts here:

  • AnimalTaxonomy. The purpose of this concept is to make available (in this system, to the zookeepers and the public) knowledge about different kinds of animals. Its state would be a taxonomy of species, genus, family etc of different animals and their characteristics, and its actions would allow the updating of this catalog as it gets enriched, corrected, etc over time.
  • AnimalIdentification. The purpose of this concept is to identify each of the animals in the zoo, assigning it an identity (including distinguishing markings etc) and a kind from the taxonomy. Its state would be a database of identifiers and types, and its actions would including assigning a kind to a particular animal, and perhaps revising that over time.
  • AnimalCondition. The purpose of this concept is to track the condition of each animal. Its state would be a log of observations, tests and interventions, associated with particular animal ids, and the actions would record those.

Does this make sense?

Thanks. That has helped very much to identify potential concepts in this scenario.

Based on the three concepts you have proposed the discussion would continue like this:

Certain users would be responsible to connect each property that is part of an AnimalCondition to a column in an external database that contains actual values (maybe originating from some smart sensors). For this task, he needs to know which properties are expected for a certain animal and the system should keep track of which properties are already assigned to signals from the database.

The question is whether there should be a list of properties associated with each type of the AnimalTaxonomy or whether there should be another concept AnimalConditionTemplate, whose state would be a set of templates, where each template is a list of property definitions that specify which properties are relevant for an AnimalCondition. Each template could be assigned to one or multiple animals. For example a template for animal born in freedom would have additional properties related to its origin and mode of purchase and could be assigned.

For the sake of the discussion, let us assume a single template is sufficient to describe all relevant properties of an AnimalCondition. Maybe we can consider an extension to combine multiple templates later.

The idea is that it would be way too tedious to reinvent the set of relevant properties for an AnimalCondition for each individual animal. So thr purpose of AnimalConditionTemplate would be to predefine commonly used sets of properties that can be assigned to animal to define details about their AnimalCondition.

Francis is in favor of directly attaching this list of relevant properties to the AnimalTaxonomy concept.
In simple cases the set of relevant properties depends only on the type of the animal, in more complex cases one could just add further types to the taxonomy as required to express a certain AnimalCondition. For instance a type “ZebraBornInFreedom”.

Steven argues that this is overloading the concept leading to unnatural taxonomies, artificially extended by types whose purpose is related to AnimalCondition.

Francis understands that very complex cases would blow up the type hierarchy but says that they will not be very frequent and having a separate concept for AnimalConditionTemplates makes the overall system hard to understand.

Currently, they feel like we might have 4 potential concepts:


The question seems to be whether the inclusion of the template concepts provides an overall benefit.

I feel that in the discussion between Steven and Francis there is a certain tension between the way we may structure the problem using concepts (as defined by Daniel Jackson) and the way we may structure it using object-oriented classification.

In 1991 Michael Jackson wrote in one of his wonderful papers (Object-Orientation: Classification Considered Harmful) about some of the difficulties that object-oriented classification can introduce into problem analysis.

Here we may see these difficulties when multiple classifications (“ZebraBornInFreedom”) and/or dynamic classifications (“PregnantAnimal”) apply to the same animals.

If instead we only focus on the concepts, those difficulties are no longer here: “multiple classification” is naturally supported, because an individual can participate in multiple concepts (in their states), and “dynamic classification” is naturally supported, because an individual can enter and exit the state of a concept by its corresponding actions.

1 Like

I think the footnote 42 from “The Essence of Software” is relevant in this situation (and in many design discussions I had in the past :slight_smile:) We need to stop thinking in terms of ontologies and ask ourselves instead what domain of actions the software will automate.

As Dr Jackson said above, when managing a zoo, the concept of identity for an animal will likely be relevant. This identity will have a set of attributes, some never changing (e.g. type), some changing rarely, and others changing almost every day. Those attributes and the kinds of actions that the zoo employees do will drive what other concepts/properties are required for each animal. Those do not only depend on the type of animal, they can depend on their sex, on their medical history…

Trying to define categories or even mixins like “ZebraBornInFreedom” is in my opinion a dead end. It is likely impossible to imagine all the situations that would require custom properties/actions. I think it is best to look at what the zoo employees do every day and extract generic abstract concept for it. For example, they probably need to have concepts like “Schedule” to take care of regular care for animals but it is not relevant why this care is needed. The system should support a generic schedule mechanism. That’s what I mean by basing the design on “actions” rather than “taxonomies”.

What do you think?


I agree with your statement that we should stop thinking in terms of ontologies, at least when we are doing concept design. I would add that something similar is true about attributes: they should not drive the concepts; it should be the other way round.

So in the AnimalIdentification concept, I would only include state that is needed to identify an animal. Other attributes (state) would be part of other concepts on an “as needed” basis.

Does this make sense?

1 Like

Great discussion.

I just want to highlight a point that I have probably not made very clear.

The zoo software is supposed to be sold to many zoos. Each zoo manager should be able to organize animals according to his own specific criteria.

The discussion is around which base concepts do we need to provide so that each zoo manager can tailor it to his specific circumstances.

We realized there is one concern related to classification of each animal to a certain type and one concern is associating certain attributes to an animal. The initial discussion was whether both concerns should be addressed together by associating attributes to types or whether types should be unrelated to the attributes. The question was whether thinking in terms of concepts may help as we felt it may have something to do with overloading concepts.

1 Like

You are right, we are not done yet. :slightly_smiling_face:

Before we go into the discussion about the customization, I have a question for @dnj about the AnimalTaxonomy and AnimalIdentification concepts.

It seems that AnimalIdentification is using AnimalTaxonomy directly, as its purpose says (“assigning it […] a kind from the taxonomy”).

In this case it could seem quite natural that AnimalIdentification would be coupled to AnimalTaxonomy (the coupling point being the set “Kind”), but on the other hand we really want concepts to be (completely) independent.

So my question is: Would we define AnimalIdentification with a generic “Kind” (and connect the two concepts later) or would we define it using “Kind” from AnimalTaxonomy directly? (I don’t know if the latter is even possible using the notation of EOS.)

1 Like

The initial discussion was whether both concerns should be addressed together by associating attributes to types or whether types should be unrelated to the attributes.

It depends what the purpose of types are. If types are used to communicate with the public and provide a type-specific data sheet for each animal then it makes sense to attach those attributes to types. This is the “AnimalTaxonomy” concept proposed above.

But I would not represent any other concern using this concept. If the zookeeper need to store information related to the animal condition or care then different concept(s) need to be introduced.

1 Like

What a great discussion with so many interesting observations! A few thoughts:

  • Operationalizing our questions. I’m not averse to taking a philosophical approach particularly when it can help us highlight a contradiction in our thinking, or help us resolve a puzzle. But generally I find it very helpful to try to return all questions to operational ones, asking what the impacts on developers and users are in very concrete terms. This is the point I’m making in Note 42 that @benfle cites (thank you!) which is saying in part that object oriented ontology questions can take us in an unproductive direction, and thinking about what functionality needs to be supported can be more helpful. Also, as @abo notes, attributes are best regarded as derived from functionality rather than someone having to exist for some ontological reason. @benfle points out that in the case of the animal taxonomy attributes, these might follow very directly from what users expect to see about animals.

  • Template for animal conditions. In that spirit, @fabian’s point that some kind of template mechanism would be useful seems spot on to me. There will likely be subsets of the animals that need to be tracked in different ways. and some kind of template concept seems like a reasonable way to capture the commonalities (and avoid having lots of optional fields).

  • Overloading of taxonomy. Addressing @fabian’s particular question, I’d side with Steven who argues that Francis’s proposal to put the template mechanism for animal conditions inside the Taxonomy concept is a bad idea, and that it’s a form of overloading. It’s tempting to put the mechanism there, because the templates seem initially to be aligned with animal taxonomy types. But then as Francis himself notes, to distinguish animals born in freedom from animals born in the zoo you’d find yourself extending the taxonomy with types like ZebraBornInFreedom. And it seems to me there’s no end in that. What about the animals that are in the petting zoo and get more contact? Or the ones that are getting special treatment after an injury (a dynamic category)? These classifications seem neither to align with the natural taxonomy, nor do they seem to have any value for a developer who just wants the taxonomy concept. So both separation of concerns and clarity of purpose are likely to be compromised by doing this.

  • Dynamic and multiple classification. I agree with @abo that structuring with concepts lets you avoid the traditional complications of OO-like classifications. In general, each concept can impose its own classifications on objects, and those classifications can be overlapping and dynamic. There’s no reason you couldn’t use an OO type hierarchy inside concepts (and just never expose them in the interface).

  • Maintaining decoupling. I was sloppy in taking about how AnimalIdentification might assign a type to an animal, while the concept that creates and manages those types is AnimalTaxonomy. @abo caught this and correctly noted that to ensure that the concepts are independent and uncoupled this will require AnimalIdentity to refer to the animal type using a generic type variable (which would be instantiated when the concepts are composed).

  • Decoupling condition templates. Finally, here’s one part of this whole scenario that I don’t have completely resolved in my mind and that you can all help with. The easiest way to deal with the condition templates is to say that they are part of the AnimalCondition concept, which would include both the functionality for defining the templates for animal kinds, assigning the kinds to individual animals, and then maintaining the instantiated templates. But, as I think @fabian is suggesting, it would be nice to separate out the template functionality into its own concept. But we’d like to do that in a way that doesn’t make the AnimalCondition concept actually dependent on the Template concept. This is a pattern that arises in many contexts where templates are used, so it would be great to solve it. Ideas?

1 Like

Thank you very much @dnj for taking the time to write such a nice and helpful answer!

It will be interesting to further discuss the AnimalCondition and Template concepts.

@Fabian, am I understanding the need of the zoo managers correctly that everything they would like to express about animals in the AnimalCondition concept could be done based on template properties?

If that’s the case I wonder if we should make the AnimalCondition and Template concepts completely generic, because they don’t seem to be animal-specific anymore.

What do you think, would it make sense to go into this direction?

Interesting questions.

Yes, I think we could generalize the concepts and just talk about entities instead of animals.

Initially, the assumption was that Templates describe all attributes that are of interest reg. an entity.

However, we found out that users do not always know a-priori which attributes are relevant for a given entity. And, indeed, in some cases the set of relevant properties may change over time.

It appeared that there were at least two different concepts to choose from. First, one where entities and concepts are tightly couples and changes to either must be somehow synchronized. Second, one where templates can be applied as a are mere shortcut to create multiple attributes at once.

At this point we realize that we do not really understand what is needed but rather explore the range of options that appear to us. Maybe there are at least two archetypical concepts here": Aspect (or Facet) and InstanceTemplate.

Cool, let’s assume we talked to our customers again and found out that being able to describe animals using template properties would be truly useful to them.

What if we would address this with one generic concept, for example TemplateProperty? Its purpose would be to describe entities using properties based on templates. Its state would cover the assignment of properties to templates, assignment of template instances to entities and assignment of values to instantiated properties. Its actions would allow defining the templates, instantiating them for entities and setting values for instantiated properties.

Why would I prefer to do this in one concept rather than two? In addition to the reason @dnj gave above, that it just seems simpler to do it this way, I also think the two parts truly belong together. Why would we want to define templates and not use them?

What do you think?


I have to admit that I am struggling a bit in bringing all these ideas together. Currently, I think of three concepts

Taxonomy: Lets you define a hierarchy of classes, define a mapping between instances and these classes, define attributes that belong to each class and set their values for each instance. Attributes would be also inherited from superclasses (not their values).

Aspect: Lets you define a a set of aspects, define a mapping between instances and these aspects, define attributes that belong to each aspect and set their values for each instance.

Identity: Lets you assign a set of identifying properties to each instance.

  1. How are these concepts different from each other? All of them serve to associate certain information in terms of attributes to instances.

With Taxonomy the user can define sets of attributes (incl. the class itself) that describe the class of entity. These sets are arranged hierarchically and some inheritence between classes is expected.

With Aspect we define sets of information that are grouped according to any concern of interest.

With Identity there is a predefined, fixed set of attributes with identifying attributes.

In all cases, we assign sets of attributes to instances. Taxonomy may be a special case of Aspect - or maybe all 3 are variants of a more generic concept.

Maybe the more general concept is Template: lets you define sets of attributes to instances and set their values.

One reason for being biased towards distinguishing Taxonomy and Aspect is that I keep thinking of mapping one of them to a certain data model such as RDF/OWL in which a notion of classes is predefined. However, maybe this is a mistake.

  1. Are the concepts independent of each other? We discussed whether Identity should be linked to Taxonomy when instantiating an instance. However, I think that all 3 stand rather independent of each other.

Thank you for clearly explaining where you see the difficulties.

Let’s assume, we are still talking about the zoo.

Maybe a good start to try to clear things up is if we look again at the AnimalTaxonomy concept. It seems that we have a very different understanding of it. As I understand the concept proposed by @dnj and @benfle, it is not concerned with individual animals at all, only with structuring biological terms and maybe information that applies to whole categories of animals, e.g. information you would expect to see on an info box next to an animal cage in the zoo.

Does this make sense so far?


I thought similar about the taxonomy concept, except that I assumed it would predefine attributes of the individual animals for example wingspan for birds. Then each individual animal would have some attributes that depend on its type.

Then we would use the Aspect concept to predefine and add further sets of animals that do not depend on the type but are rather crosscutting such as attributes related to the zoo it was born in.

The Identity concept would add some more attributes mainly some IDs for different external systems in which the animal is registered. Maybe even some less formal attributes describing how to identify it manually.

The underlying assumption is that the main purpose of the system is to look up information about individual animals. The challenge seems to be be some information may depend on the type of animal and should follow a hierarchical taxonomy, some should be based on other aspects and some should be predefined. Further everything should be customizable by each individual zoo manager, i.e., defining new types and aspects, defining attributes that belong to them, assigning types and aspects to individual animals, and setting the values either manually or by somehow connecting external systems, e.g., with live data. The system should provide several options for search and exploration. For instance when selecting an animal all its relevant attributes would be displayed, structured by the underlying aspects.

I see. Perhaps the zoo as a metaphor for the problem you are trying to solve could be distracting us here. What if we instead would use a problem statement like the one you gave in the last paragraph and see to where we get from there. Would that be more helpful?

Yes, to be clear, I am very thankful for the deep discussion so far and it already is very helpful.

I think the discussion so far has helped me distill the underlying problem to some point. So I provided the summary of the problem statement in my last response as a way to potentially direct the discussion towards this current view of the problem. So if anyone has some further thoughts on this, I would be very interested to read about it.

Cool, I think we might already have a good part of what you are looking for.

Let’s see what happens, if we take the TemplateProperty concept from above and tweak it a little.

What if we said that there are two kinds of template: type-templates and aspect-templates. Type-templates can be structured in a hierarchy. Aspect-templates would be plain templates in the old sense. There could be additional rules for assigning templates to (entity) instances, so that each instance is connected to exactly one type-template and any number of aspect-templates. The set of instantiated properties for an entity instance would contain the properties of the templates that are directly assigned, as well as the properties of the ancestors of the assigned type-template. The rest would work more or less in the same way as before.

This is just a very rough and incomplete sketch, but I think we could make it work as a concept. What do you think?

Thanks, this sounds very good. I also think the whole Identity concept could be submerged by this template concept. Identification could just be another aspect.

One open question reg. Templates is whether they should be tightly coupled to an instance or whether they just serve as a shortcut to create multiple attributes at once.

We realizes that it is hard to predefine templates totally correct or sometimes the set of relevant attributes might even change over time. So if I want to change a template that is currently used by an instance I would have to synchronize these changes accordingly. Sometimes I would not propagate the changes to all instances but instead have to create a new variant of the template and assign it to a subset of instances only. I would also have to define whether it should be allowed to delete attributes from an instance. In this case it would be of no much use to maintain the association to a template at all - it gives no guarantees about which attributes an instance will have anyway.
So this leads to the other alternative, that is more loosely coupled. In this case, there are no guarantees on which kind of attributes an instance actually has. The purpose of templates in this case is merely to save time when creating attributes for a given instance.

Is it possible that behind my thoughts lie two different notions of a template concept? This is something we were not aware of in the beginning and have to admit we do not have a basis to solve this tradeoff between increased solution complexity (for the flexible solution) and the benefit of being able to maintain guarantees about attributes.

My approach would be to start with the flexible approach and observe a few actual customers, see how they structure their systems according to classes and aspects and then further decide on how to proceed regarding the different variants of template concepts.