Danny's CIS327 BLOG

.NET Intro links

2005-03-15T18:09:00.000-08:00

.NET 1.1 SDK

SharpDevelop (open source C# IDE) I haven't used this yet, just downloaded it the other day. We use VS.NET at work and I have an MSDN subscription through work too, so I haven't had much need to dig into the free offerings. But I'm starting to.

Other alternates Again, I haven't had a chance to check them out in depth, but their starting to gain some momentum.

Mono (cross-platform .NET runtime)

.NET help Check out the .NET Framework Class Library. There are also some decent "Getting Started" examples and stuff. It's just kind of hard to get used to finding stuff because there's so much of it. I have the same problem when I try to learn a specific Java thing from the Sun web site.

Composites

2005-02-22T19:45:00.000-08:00

...are strong aggregations. In this type of relationship the component parts usually cannot 'stand on their own'. One example might be a Chair associated with Legs. Legs alone are pretty worthless (at least for chair legs). This association is represented with a closed diamond in UML.

Aggregation

2005-02-22T19:37:00.000-08:00

...is when a class consists of a bunch of other classes that represent components of the 'main' class. These are basic associations between a class and its components in a whole-part relationship. As mentioned under associations, these are represented in UML with an open diamond.

Inheritance & Generalization

2005-02-22T19:35:00.000-08:00

Generalization is the UML term for inheritance in which a parent or base class is a more general case of the child or subclass.

Reflexive Association

2005-02-22T19:31:00.000-08:00

...this is when a class is associated with itself in a recursive manner. In UML this is represented by drawing the associative line back to the class it started in with both ends stipulating the role in the association. A an example of this might be something where multiple roles are performed by the class in question, like a ClassRoomOccupant. An instance of this class could be a Teacher or a Student, in which case there would be a single Teacher with multiple students.

Qualified Association

2005-02-22T19:27:00.000-08:00

A qualified association helps resolve the 'lookup problem' in a one-to-many association. By specifying a unique ID the 'many' class, the 'one' class can essentially reduce the association to a 1 - 1 by looking up a single desired instance from the list of many associated with it. In UML this is denoted with a rectangle attached to the class that does the lookup.

Multiplicity

2005-02-22T19:24:00.000-08:00

...denotes the magnitude of an association, the number of one class vs. the other in the relationship. Multiplicy expresses the limits of the relationship on both ends. For example, with the Book and Page association, you have a many-to-one relationship. Multiplicity values for my Java book would be 1 - 1447 (counting only the numbered pages). For the Car and SteeringWheel association the multiplicity would be 1 - 1.

Association

2005-02-22T19:17:00.000-08:00

An association defines a relationship between two classes. This relationship is usually in the for of aggregation, or a 'has-a' relationship. For instance, a Book has Pages, so the relationship is an association (many-to-one) between Pages and Book. In UML these aggregations are denoted with an open diamond at the (has-a) end of the association line.

Encapsulation

2005-02-22T19:10:00.000-08:00

...is the act of keeping the attributes and behaviors (properties and methods) of objects together in cohesive units, which are classes. Encapsulation provides objects with the ability to limit access to their internal data, information hiding, through public interfaces that can enforce rules on how that data is manipulated.

When used properly this technique helps prevent problems with objects entered unknown or invalid states in their data. The whole concept of 'getters' and 'setters' is a standardized way of providing public access to data with a formal interface. The implementation of these methods can ensure the data being entered is truly valid for the object.

Polymorphism

2005-02-22T19:02:00.000-08:00

The OOP concept of polymorphism allows you to treat many different classes exactly the same by dealing with them 'in the general' rather than 'in the specific'. There are some rules to follow when using this in an implementation. First, the types must be 'compatible'. For instance, if I have a class called Object with a method toString(), and a subclass of object called MyObject. I can create a function that outputs to the console the string representation of all instances of type Object (and derived types) simply by having it utilize the basic Object type.


public void outputToConsole(object data)
{
     System.out.println(data.toString());
}

I can use any instance of type Object or MyObject with this routine because of polymorphism. It works well with interfaces too, which is a very good way to create extensible frameworks.

Inheritance

2005-02-22T18:48:00.000-08:00

... is where once class derives from another, thereby aquiring the interface and implementation of the derived class (based on scoping rules of course). This allows for a significant amount of code reuse and for adapting existing, proven, tested code only as needed to create the needed functionality.

In a more sing-song way, inheritance represents and 'is-a' relationship between one class and another. For example, a Dog 'is-a' Mammal and would inherit several features from that class such as live birth, suckling young, warm-blooded and so on.

Design Patterns References

2005-02-01T17:17:00.000-08:00

If you're interested further in design patterns, this is the book by the GOF:

Design Patterns
Elements of Reusable Object-Oriented Code

Erich Gamma
Richard Helm
Ralph Johnson
John Vlissides
(Gang of Four)

My well-warn copy has ISBN: 0-201-63361-0

A decent online companion to it, from a Java perspective, is at: http://www.fluffycat.com/java/patterns.html

There are several others too. Just Google "Design Patterns". Also, check out the Wiki at http://c2.com which has a LOT of conversation around software architecture, design, and craftsmanship. Plus Wiki's are cool.

Abstraction

2005-01-25T19:32:00.000-08:00

This is the process of extracting the similar attributes (commonalities) of entities within a model. To use an time-honored example from an impromptu hierarchical species classification system, a Boxer and a Bulldog can be abstractly described as Canine, which can be abstractly described as Carnivore, which can be abstractly defined as Mammal, ...

All Canines have four legs, binocular vision, social behavior, (and so on) and Boxers and Bulldogs certainly fit within that more generic description. Then each of them specializes upon that generic definition to varying degrees, exhibiting properties that are not necessarily present in ALL Canines (like excessive drooling).

And while Feline certainly fits within the Carnivore description, they definitely are different from Canines (sheesh, the two can't even live together without mayhem!), so that defines another branch of Abstraction below Carnivores that might contain Leopard, Margay, Ocelot, Tabby, yaddah, yaddah.

For what it's worth, I've found that for real systems, the more compact and 'differentiating' the layers of abstraction are, the easier the system is to conceptualize and maintain, meaning that more abstract classes can be easier to use in a variety of situations. For instance, it might not make sense to actually model Boxer and Bulldog, as the attributes specific to those types of Canines may not be relevent to the model, or they may be handled by 'enumerated properties' in the more abstract class. This can kind of lead away from PURE OOP depending on how it is handled, but huge object hierarchies where only one property is overridden in a subclass can be a bear to keep your head around. And while Polymorphism goes a long way, some design patterns (like Visitor) can help alleviate the need for both highly specialized classes AND specific logic codified into more generalized classes.

Definitions Assignment

2005-01-25T17:40:00.000-08:00

Our assignment is to create BLOG entries for each of the following terms:

1. Abstraction
2. Inhertiance
3. Polymorphism
4. Encapsulation
5. Association
6. Multiplicity
7. Qualified Association
8. Reflexive Association
9. Inheritance & Generalization
10. Aggregations
11. Composites
12. Contexts
13. Interfaces and Realizations
14. Use Case Diagrams
15. Class Diagrams
16. Object Diagrams
17. State Diagrams
18. Sequence Diagrams
19. Acitivity Diagrams
20. Collaboration Diagrams
21. Component Diagrams
22. Deployment Diagrams

I'll be creating an entry for each as time goes on...they'll be available by clicking on the individual list items above, as I get to defining them.