The other week I posted on Google+ about the warm fuzzy feeling I'd gotten when writing this line of code:

public class Poster extends Entry implements IEntry

Why so? Because all the classes involved were of my own making. Finally things had started to come clear to me; I understood the importance of class inheritance and the role of implementable classes.

While I'd kind of understood this for a while it wasn't until it all clicked and I actually did it for myself that I could truly say it really made complete sense.

The Poster class the code refers to lives inside a Flex-based app I've been working on for a while now that lets school kids create artwork from photos they've taken by adding their own words to them. The app is the closest I've come to making actual software. 

As well as posters they can create a Calendar, which is also an Entry-based class. Posters and Calendars both consist of one or many pages. For this there's a Page class, which has a property that defines what size of paper it's based on. Ultimately the kids will print out their entries, so the paper size is important, so as to get the proportion of width/height right.

In order to define the paper sizes available I created another class called PaperSize, which you can see below (the code is ActionScript 3, but is a lot like Java/most other languages).

package 
{
    public final class PaperSize{
        
        public static const A4:PaperSize = new PaperSize(595, 842, "A4", "A4 (International)");
        public static const Letter:PaperSize = new PaperSize(651, 842, "Letter", "Letter (US)");
        
        public var width:int;
        public var height:int;
        public var name:String;
        public var description:String;
        
        public function PaperSize(width:int, height:int, name:String, description:String){
            this.width = width;
            this.height = height;
            this.name = name;
            this.description = description;
        }
        
        public static function AllSizes():ArrayCollection{
            return new ArrayCollection([
                PaperSize.Letter,
                PaperSize.A4
            ]);
        }
        
        public static function get Default():PaperSize{
            return PaperSize.Letter;
        }
        
        public static function findByName(name:String):PaperSize{
            for each(var size:PaperSize in AllSizes()){
                if (size.name.toLowerCase()==name.toLowerCase()){
                    return size;
                }
            }
            return Default;
        }
    }
}

Again, the fact that I wrote the above code un-aided and without any kind of copy-pasting off the internets was nothing short of a revelation for me. Once again I got that nice feeling, knowing that I'd written the class all on my ownsome.

I'm not saying the above PaperSize class is perfect, but it works well for me and does everything I need it to and in a way classes were meant to (at least as I understand it).

I'm sure you guys can offer suggestions to improve it (and I welcome them) but my point here is that I finally understand how and when to use static classes. Finally, it's all coming together.

It's not only writing the classes that give me a nice feeling. I get the feeling over and over again each time I refer to my classes and type-ahead popups, suggesting properties that I made appear there, as below:

With the class I can do things like:

page.height = PaperSize.A4.height;

or

paperSizePicker.dataProvider = PaperSize.AllSizes();
paperSizePicker.labelField = "description";

or

entry.paperSize = PaperSize.findByName(xml.@size);

The findByName() method comes in handy as each Entry gets stored as XML, so the students can come back and re-load/edit them at a later date. The XML holds the name of the paper size used and I can reload it when needed.

My point? Not sure really. As ever, just sharing my adventures in coding. Also wanted to share my excitement that - after 15 years as a "developer" - I can finally call myself a programmer without feeling too much like a fraudster.

What about you guys? Am I the only saddo who gets a kick out of seeing their own classes' properties and methods appear in code type-aheads when programming?