Personal Blogs

Some thoughts about today and tomorrow and some stuff about solitaire.

As always, but there is some other stuff.

 

When I originally wrote the hashCode(), equals() and compareTo() methods for the Peg Class I didn't really think about comparing Boards.

Now that I'm there I see serious problems. I can write an algorithm, but even in pencil, on A4, it looks strained. And that's just for an English Board.

The problem is that Boards should be equal if you can rotate them onto one-another [I decided that reflection was out, which might be another mistake].

The good thing is that I can change things without a, "cascade of failure". The bad thing is that, for the moment, I can't see an easy way to do it.

I'm stuck with a hard choice: easy Peg, hard Board. Or vice-versa.

[See my previous post]

Creating the XML wasn't difficult, I knew that it wouldn't be. Parsing the thing back will be a bugger.

There's a big bit of me asking why this is should be so. It's not as if XML isn't a standard. Someone should have made this easy. But..

If I bump into a bod on the street and start talking Topology [not there yet, but will be sometime soon ], I'm seen as a benign idiot; I start talking XML and I'm a signed-up-member-of [insert your favourite hate group here].

True, the thing was, and is, used wrongly, but we can say this about any data format, can't we? Morons used it when they shouldn't, it's still better than anything else we have. Or do you fancy openDoc?

Who knows. But it is, funny? One of the major techs that drives the web is named after XML, which it doesn't use. AJAX [Asynchronous Javascipt and XML].

Only a moron loads XML, because you have to fork IE and normal browsers' javascript... [I've tried, if you want the almost working code drop me an email.]

Jings! I've just realized that I need to care not one iota about how others are going to use my stuff. I'm off the leash for once.

So it's going to be XML. Plus.

 

Today I downloaded the first TMA for the Topology course; the books haven't even been posted yet. Still, come late[-ish] February the thing [the TMA] and its associated PT3 will have to be with my tutor. It's getting serious again.

So, fin de siècle, I've been playing around with my solitaire thingee. I fear that in the near future the poor beast will become neglected. No...that's not right...what's the word that I want? Oh yes, broken, utterly broken.

I've built many a poor beast over the years, all have proved flaky, shoddy, ill-considered and, in-the-end, worthless. For once, this time, I've built something that has some legs [if only in my head]. I know this because I'm having to go out of my way to break the thing; usually this happens by default. On a simple opening.

[It also does some of the things that I meant it to do.]

I don't want to destroy it. But destroy it I shall if I hopelessly-hack-at-it during the few idle moments that I'll have between now and October. Version control is all very well—you can rewind the code. What you can never do is put yourself back into, "knowing what you [meant yourself to be] do[ing]". If you have no documentation, that is.

So I've made a decision: this weekend I'll collate all the pages (bits of paper), that I can scavenge from the scattering of the floors, into a specification, I'll re-do my to-do list, I'll write down my feature requests, I'll make a plan, I'll finish the tests, I'll make sure that the Javadoc makes sense. I'll do what I should have done.

So that, at moments of stress, when maths hurts and I seek the balm of code, I might, do something useful.

Won't, won't and won't.

For the last couple of days I've been working on my solitaire thing, lying in bed and trying not to think about going back to work.

The solitaire thing: looks awful, the code is gnarly in too many places, there isn't much (any) error handling, the test-harness is patchy, the documentation is scant and the TODO list is huge. But the major components [bar one] are all now in place.

There are issues, but these are issues that shouldn't cascade—I can work on them without worrying that I will break-the-build. The main plumbing has been done, all I need to think about now is what the sinks, taps, bidets etc. will look like/do.

Well not quite.

The main reason that I started building the thing in the first place was that I was interested in the game itself. In studying it mathematically and studying AI. I'm still a while off doing that yet.

That's the big [bar one] that I don't have in place—the analysis module. [Although I'm not sure that it is going to be a module!] It's all very well being to open/save games, write the code for a new board/move/player and just have this happen, what I really need to do is...

There's a wee bit of me that just wants to forge ahead. I've built-in a few things into the model to help, and the model is set up so that it should be easy to build-in many more of such things. This would be a wrong thing to do.

So what I'm going to do is to fix the things that are flaky, every day when I'm tired of doing that I'll get out a pencil and paper and see if me not thinking about the main problems has been a help.

What's been done so far isn't too bad, but then after studying computing for three years now, it shouldn't be.

I'm in new territory [computer-wise], time to make ensure that I've built the foundations right, even if I'm thinking about the roof while I doing that.

 

I hacked away for a couple of hours today until it became obvious that I was flailing hopelessly. So I closed NetBeans and got out a notebook and pencil.

As soon as I did this it all began to come together. This often happens when you're coding—it isn't until you stop that you get an idea of the what it is that you should be doing. Of course, I know this, but I rarely use any of my knowledge.

Since my good idea [see my last post] I've been changing the architecture of the solitaire thingee. Somewhat of a silly thing to do without an entire new spec. When I started the thingee I did have a plan; but when you change said plan? Possibly a good idea to firm-up your concept of the new one? Not something that I did.

My trouble is that I play games [online Go at the present], you're not allowed to try things out, except inside of your own head; what I forget is that I spend rather a lot of my time being physical so that I can do the mental when it comes to games. Still I like to plan in the falible software of my head, despite knowing that this is an idiot thing to do.

That's why fags are important: you have to go outside; where you have to stop doing, and you have to think.

I spent a few hours today hacking the Java solitaire thingee, I'm close to a landmark. Which would be a human playable GUI the can store my games to disk.

Some of its internals are a wee bit iffy, the look/GUI is awful and I really do need to revisit the unit tests. Still I'm pleased on the whole.

Mostly what I'm pleased about, is that, for once, I did something well—I'd planned an Observer pattern, but plans and fulfillment are often strangers to one another. But when I plumbed the thing together today it worked [almost] seamlessly. What was particularly pleasing was that I could insert Objects [almost everywhere] and it still, just, worked. I'd meant this to happen, but such outcomes do not always occur in my experience.

I'm tempted to crash-on. That would be a wrong thing. In a couple of places my Objects didn't perform in the way that I'd expected them to, despite the tests that I'd written. As Phil W says, the first step is to, "write a failing test". I don't have much trouble writing failing tests, but I know what he really means—if you can write the test you can write the code; and you should write  the test before you write the code.

Anyway tomorrow I write the I/O. I think that I'm going to go for string [UTF-8] and XML. And possibly HTML. I won't be serializing any Objects any-time soon methinks.

 

In my madness I've decided to air my thoughts about solitaire. This may prove to be a trial to both me and you, my gentle reader. Still done now.

At some point in any project you are going to begin hacking; Objects are beginning to know a wee bit too much about each other, we are playing pass-the-parcel with said-same and we keep having to re-visit them to add, "positively the last method".

In short you are starting to create an Italian staple: spaghetti. And you are probably adding a piquant sauce to your error.

It doesn't matter how carefully you planned, it doesn't matter how well it looked when you drew the diagrams, it doesn't matter about your elegant proficiency with the CASE tools. You will stuff up—you'll start balling string [lower-case] into a weevil's-nest of knots. 

At this point you need to step back and plan again.

The problem is that the we think that 'our thing' is working. This is a snare, a deceit and a trap of our arrogance. Working in what sense? That it's passing the unit tests? Or that your end-users can use it [when did we care about them?], or, worse, that you can use it. Bad code is bad code. Accept that you are going to write wrong; learn to feel when you're doing that.

We don't start out to write crappy code, but write it we shall and will, and if we don't grok the moment[s] when we start to do it we will always do so. Coders need a reset: we should know when we when need a re-think of our initial mal-assumption. For such moments will come. In their droves.

My personal test is that if I change a Class and it burns the tree in a place I didn't expect it's time for serious thought.

Actually that's not my only test, there are many [if I'm starting to chain too much I get worried; my reason for disliking JQuery , but there are loads if you look] You have to develop your your own Zen in this matter.

Yup, I'm there with my Solitaire thingee.

 

Today I've spent around six hours hacking Java: good. I'm recreating my solitaire programme...not so good [I can hear some people screaming at this point.]

I don't intend to delve into history here, those of you who have been reading this blog for some time will know of this thing of old. [And Phil & Robb, who actually managed to get a working app. together last year, must be screaming the loudest.] Still.

I had a thought; what about 3-D solitaire? It was the book on partial differentiation that gave me the idea. Indirectly.

I went to bed very early last night, much drink had been taken. Thus I awoke early. I was lying in bed trying not to think about going to work, so I tried to visualize what was going on with partial differentiation. I won't bore you with my suppositions, they will be wrong, but it did get me thinking about how two 2-D solitaire boards might interact. Hence 3-D solitaire.

When I got to work [work] I started thinking about how this could be studied [some form of lego will build the board]. Which lead me to open up one of my many solitaire programmes. I thought that I could see a way to do it better...

I'm probably wrong, but if the only thing that I manage to achieve is to get me programming again then this is still gain territory. As long as I'm coding something I'm at least alive, to a certain extent.