Software Engineering – Summary

I didn’t make these, but Nida has kindly made a summary for software engineering and asked me to publish it, so here it is! Read more of this post

Software Engineering – (System) Sequence Diagrams

Now it times to learn all about how to create a (System) Sequence Diagram (SSD).

Note: not to be confused with State Diagrams, hehe 😉

Read more of this post

Software Engineering – Activity Diagrams

Its time to demonstrate how to produce an Activity Diagram – here we go.

Read more of this post

Software Engineering – Object-Oriented Modelling

So, this is it. This is the post that ties all the previous three together! That is:

  1. Class Modelling
  2. Functional Modelling
  3. Behavioural Modelling

So lets have a look then shall we at Object-Oriented Modelling 🙂

Read more of this post

Software Engineering – The Behavioural Model

this post is the final post of the three main modelling systems in Software Engineering. So far we have seen Class and Functional Modelling; now it’s time to take a look at Behavioural Modelling! 🙂

Software Engineering – The Functional Model

In this post we talk all about Functional Modelling. This post is a semi-continuation from the previous one on Class Modelling.

Read more of this post

Software Engineering – The Class Model

Hey everyone it’s Badgerati again 😀 Sorry i haven’t exactly posted anything in 3 weeks… But if everything goes to plan, there should be 3 updates tonight!

So, lets get them all started with Class Modelling! 🙂

Read more of this post

Using NetBeans 6.8 to Create a Tab View

Hey guys,

Here’s a video that may come in useful when developing GUIs for Java application using NetBean’s interface builder. Read more of this post

Software Engineering – Domain Modelling

What is Domain Modelling?

Domain Modelling is a way of representing the context  in which the software must operate – to understand the software better. However, one must remember that you’re not modelling the software to be built!

A better description would be:

A Domain Model in Software Engineering can be thought of as a conceptual model of a system which describes the various entities involved in that system and their relations.



Domain Modelling 101

  • Go through the available data sources; such as the original description; Use Cases; Glossary etc etc. With this, you must then identify possible Domain Classes (noun phrases)
  • Identify basic relationships between the domain classes.
  • Add addition key attributes
  • Pay attention to the relationships, like names and multiplicities – it is very important that these are correct!

Domain Modelling Example

Now for the moment you’ve all been waiting for, an example! 😀 Sadly a Domain Model doesn’t have any stick people in it, so there’ll be no awesome stick people of awesomeness 😦

Lets say we have the following information for a basic Student Library System:

Courses may have recommended items of Reading Material, which may be either complete Books or individual Chapters. Items of Reading Material may also allows a user or floppy for every NFA there is i for for have Reviews associated with them.

Now with this we need to identify 5 classes, can you see what they are?

Hint: i cheated a little, they’re in italics…. 😛

So, yeah… we have the 5 classes of:

  1. Courses
  2. Reading Material
  3. Books
  4. Chapters, and
  5. Reviews

And with this, this is what the Domain Model looks like:



Before I start to explain what this shows, lets explain the arrows and numbers:

  •  DMline  This is the first thing. This – obviously – is a line. When we see a line connecting 2 classes together this shows us that these 2 classes are related. The text that lays on the line, ie “provides”, says that Course is related to Reading Material as a “Course provides Reading Material”.
  • DMarrow An arrow implies a relation of inheritance. So for the diagram above, its should be obvious that a Book will inherit some methods from Reading Material. A more better example of this could be if we thought of this in a Java/C++ sense. For example, we create a Person Class and then create a Student Class, a Student will inherit methods (etc) from Person, such as getAge() and getHeight() , as well as name and age etc etc.
  • DMcontain This is a line with a funny looking diamond thing on the end. What this states is that class ‘A’ contains class ‘B’. For example, above we say that a Book contains Chapters – which is obviously true, else it would really be a book…
    Another example would be if we had the classes Wallet and Money. So we could have Wallet => contains => Money.
  • The final one is the numbers; so (0, 1, *, 0..* and 1..* and many more). What these state is a relation such as one-to-one, or one-to-many. In the example above we have these numbers on the contains relation for Books and Chapters. So we say that a one (1) Book contains one or more (1..*) Chapters.

    Alternatively we can also say that one (1) Course provides zero or more (0..*) Reading Material.

    As a note, remember that we can only use these numbers on plain relation lines and contains relations. we do NOT use them on inheritance relations! 🙂

And i think that’s it for Domain Models 😀 , sorry for doing this one a little late, i had some issues with the diagram above. However, many thanks to James Bedford, Daniel Lyon 😀

Software Engineering – Software Testing Concepts

Software testing concepts

The fundamental rule of testing is that ‘a successful test is one that causes the software to fail.

You can have a testing team who didn’t write the software do this.

An agile solution would be to write the tests before the code. This helps to clarify requirements too. Read more of this post