Category: python

I'd like to learn a bit more about creating class decorators, using decorator classes. We'll write some more tests, and perhaps find some additional useful references. Fun! Learned something!

The votes are still out regarding whether my `__getattr__` forwarding is too clever or not. This morning, I'll at least do a little learning about class decorators in Python. Language Preferences. Fun. Trouble. Learning styles.

Something about the Bot class bugs me. Python must have a good way to do this. (We find a way. Is it good?)

Today we'll address the need to provide details for Bots to be created. We'll use a callback: it seems sensible to me.

What shall we do today, Brain? Same as every day, Pinkie. Try to improve the world.

We'll look at the list of things to work on, but yesterday's experience has sort of set me back on my heels.

The top of our list needs attention. A small concern leads to much better code. Ron talks himself out of something. Comments are clues.

We'll check our list again, to see what might be fun to do. I did get a glimmer of an idea that I'd like to explore.

We'll review our list and pick some steps toward our overall goals. We might even remind ourselves what those goals are. Or we might trust that we'll find our way.

We'll pick a next chunk of our new message format and put in in place. Will we get clear to the end? Probably not yet. Also: Pyto on the iPad.

Before taking our new message format forward, let's think about how we almost missed the improvement. "It's dangerous to go alone. Take this."

A wild idea has appeared! This one's so nice I rolled out of bed early to work on it.

Our message format between Bot and World is a naked JSON structure. That makes sense for messaging, but I don't like it for processing. I have an idea that I think will help.

The present state of the code leads me to think about its evolution, and in particular, whether evolving it as I did led to substantial 'wastage' in code or tests. The answer may not surprise you!

To entertain myself, I coded a new RequestBuilder object, much like the InputBuilder, but building a dictionary-list composite like the requests expect. Results were good. Herewith, my report, not contemporaneous.

Setting out to review the code, I discover my old InputBuilder experiment. I go one way then, the other, then back. An actual revert of a commit. No new code, but some useful thinking.

How can I possibly think and write about programming today? How can I possibly allow myself to think about anything else? More toward client-server.

The reason for setting myself this public 2X20 challenge isn't so that I can be embarrassed in front of everyone. It's because I need more practice on small steps. The downside of thinking one is particularly smart. Results: Good, but by the skin of my teeth.

I've challenged myself to work in small steps, supported by tests, integrating new code as soon as I can manage it. I think I see a path. Spoiler: Works very nicely! Lesson: Need less tension, not more!

Some thoughts on choosing small steps. I think it's always possible. Is it always the right way to go? I issue a challenge to myself.

Not a high school, no, just getting ready for client/server in our World. Much design thinking, just a bit of code, a small step in what seems like a decent direction.

I've learned a bit about C/S. Should we apply it to our Robot World? It's about Joy, dammit!

OK, I promised to test reading, and I'm gonna do it. I sort of have a plan.

I am questioning whether I need all this rigmarole, and whether I owe you some further testing of this "legacy" overly complicated Message Class. Just thinking today, code browsing, no changes.

Working to get this tutorial under test, we do a simple refactoring, so that we can test something in isolation. Trivial in this case, but a useful technique worth remembering and practicing. A wild rabbit appears!

A first quick start at some tests may help me get off the dime here. Can I trick myself?

I've reviewed the full app server example from RealPython. Rather than just run it here and work through the details of its operation, I want to get it under test. This promises to be ... interesting.

A brief report on study and what I learned, then a look at the server side. Where is the bright side? I'd like to look at that sometimes.

Today I plan to try to run and understand the second example in the RealPython tutorial. See how an old man learns about unfamiliar code.

It's time to bite the bullet, lightly, and do some real client-server experimentation. I started last night, on my iPad. Aside from that and a bit of reading, I am entirely ignorant about sockets. Let's fix that a bit.

I believe that the client-side code includes a Block class. I further believe that we have no use for it. Even further, I suspect there are tests that use it, which should not. Let's sort this out. Simple changes, nothing to see here. Refactoring works.

It almost seems like I can't work on the code unless I'm typing an article. I guess I just don't want you to miss anything interesting that might happen. No promises, mind you.

I said I'd spare you the tedium of improving the tests, but you deserve to see what kind of improvements I'm making. I do not know what sins make you deserving of that, but you can examine your own consciences.

The Knowledge class and its usage have something to teach us, I think. There are issues here that aren't uncommon. Perhaps some changes will spark ideas. Theme: battling entropy, battling chaos.

We'll take a look at the NewKnowledge prototype, but I think I'm going to go with it. No one here to talk me out of it, and I think the result will be much less cluttered. TL;DR: Not worth it. Fun, though.

I have an idea for that Knowledge class. Let's see if it Just Might Work.`

Let's take a look at the code today, looking for things that do 'spark joy' and things that don't. Intuition. Pattern recognition. Joy.

We should try to get our new WorldInput stuff into play pretty soon. But let's look around and see what comes to mind.

Let's see what additional tests and capability we need in our new little batch mode objects. What were yesterday's notions?

In client-server mode, I believe that the program will want to accept a batch of commands from a client, process them all, and return a batch result. We'll discuss briefly why, and then see about doing that.

Still on the quest of separating server things from client things, in small steps. I think we're down to just one issue, the item a Bot might be holding. We discuss refactoring vs rewriting.

OK, I forgot that World references Block class. That's why we read the code before estimating, if we must estimate. Let's break that connection. Result: small progress, but Bear Bites Man.

The demo went well. Someone spotted a dangling thread of connection between server and client. Let's fix that.

It's Tuesday, so tonight is Friday Geeks Night Out. I want to demo something new. Can I get it ready this morning? Surprisingly, yes I can!

The WorldEntity only supports Bots so far. It needs to support Blocks, and whatever other items our world might one day contain. We need a type designation. We run into just a bit of trouble. Long article, nothing to see here.

We consider things to do, pick what seems most urgent, deal with it. We have a decent discussion of estimation, planning, how to know if you're slowing down, and what to do if you are.

I'm really sure we'll get the WorldEntity at least built and tested, and very likely put into play. Or my name's not Bonzo Calrissian. A long road but a simple one. One skipped test and had to update the demo.

Armed with a bit less ignorance we'll try to create and use a new world-side entity. I have ... ideas. Result: This is why story estimation is so fraught.

No, not the fish. An idea about flavors of Blocks. Exploration, Spike, Rollback. Just fine.

We've had good luck with `take` and `drop`. Let's see if Map would like to help World with the `step` method. Some nice improvements ... and a GitGlitch.

In writing, folx refer to Plotters, who plan out the story in advance, and Pantsers, who "fly by the seat of their pants". Which am I? Which are you?

We are told that Colin Chapman used to say "Simplify, then add lightness". Can we do that today?

We have one known thing to work on. Some things to put on the list. And let's see what the code wants.

With World using a separate Bot instance, separate from the ones we use on our nascent client side, we can start making some simplifications. Let's look around. Results mostly good but not all good. Rat hole.

Woot! I believe we have a complete disconnection between the client bot and the world. The world is running its own bot and I'm sure we have no cross-talk. I provide some general observations about this long refactoring, and its general implications.

I do manage to make an important change this morning, but I had hoped for much more. Progress is really quite good but I had fireworks in mind, not just sparklers.

Let's move further toward separating the World side from the Bot side. There are options and issues.

GeePaw and I addressed a serious design error. I think we wound up in a decent place. Today will tell.

Experience, thinking, and a few words with GeePaw suggest some moves. I try some things, roll back, but think we're on a decent path.

Based on a few days' experimentation, lots of thinking, and some messages with GeePaw, I have a tentative plan for moving closer to client-server style. Things go nicely!

We try a mad idea. We discover things. We despair. We assess where we are. We get another idea that's not so good. We roll back. We refactor just the least bit. We do a tiny JSON test. The idea becomes useful. We criticize the code. We devise a plan. Wow.

Continuing changes toward client-server. We'll discuss my lack of a real plan. We'll discuss why what I want to begin on today is particularly irritating. Much thinking, little code. As it should be.

This morning, without any direct Python network communications experience, I plan to start pushing the bot world code toward client-server. Along the way, I'm going to think about what GeePaw Hill means by a Making App. We do make a small but nice bit of progress.

Last night, we shared some observations about the code. We shared some observations about how we pair. We even did a bit of nice work.

We have adjusted `can_drop` to check scent. Let's do `can_take`. Should be much the same. I'll force myself to test this one-line change.

I have a bit of time, and I'm going back in.

My demon-dispelling thoughts this morning turned up what I think is a very nice-smelling idea. I must try it.

I do like the result of my changes to the state machine. I didn't always feel good getting from there to here. Let's see what I might possibly have done better. My conclusion surprises me.

We begin to look back at the evolution of the Bots' state machine. In this article we'll quickly review the three ways we have represented the Bot state. In the next, we'll look at the process of getting from there to here.

This morning, tests for the final state class, Walking, then create the class and plug it in. Then, time permitting, I think we can simplify things a bit. And wow, can we! Early bird, meet worm. Used "rip-roarin'" in a sentence.

I plan to start with some direct tests for the state classes. I think that will be interesting. And I'm expecting to use a Test Double, which is quite rare hereabouts. Plus: Amazing Grace.

This morning, I plan to start moving more directly toward one class per state. I'll be borrowing an idea from GeePaw Hill. Any mistakes in what follows are his and his alone.

I'm going to continue with Knowledge and see about pushing it into the Machine. Should be pretty easy. (Spoiler: NEVER SAY THAT!)

Our little Bot just shouldn't be this complicated. It's not getting better. Time to regroup and change course.

Explaining the situation to you helps. Then I pick a good first step. The rest is history: Long article, small steps, excellent outcome. Good job, rubber duckie!

I promised to improve the state machine tests. I guess I'd better do that. There's probably some good news in there. I learn to listen to myself.

Alone again, naturally, as the song says. I propose to convert to a more robust form of state machine this morning. Results cheer me up a bit, sorely needed.

I propose to make some changes that I think make sense and that my cohort will not disagree with much, if at all, despite not sharing my concern. As GeePaw put it last night, f[ool] around and find out.

I want to try an idea that I have about the client-server aspect of our little program. ... wanders off mumbling ...

We have been ignoring the requirement that this must be a multi-client one-server program. We have done nothing about that, on purpose. I think we need a bit more thinking, if not doing, on the subject.

Bryan comes up with a perfect term for what we're trying to do. We simplify one bit, improve another, must about others.

I think I'm on my own this morning. Maybe I should just open my Zoom to the public. Anyway, today let's just scan the code and see what we can see and why we see it. Maybe even do something about it.

The famous GeePaw Hill plans to join me this morning, at some point. Until that joyous time, I'll think about things we might do. We do two good things and are faced with an unknown. Note: one more thing added.

I'm planning to pair with GeePaw this morning. I have some improvements in mind, and will start on those before pairing time. We gather stones together. Well past time, you ask me.

This morning, up at 0650 for some reason, I think I'll push a bit on the "vision" idea. GeePaw arrives and helps out.

I think I'm on my own today. Feeling kind of lonely. I'll see what I can figure out.

Woke up at 3 AM with an idea. Going to work on it. I have opened my zoom in case anyone else on the team wakes up. Pairing, as always, is tricky but rewarding.

I've opened my pairing zoom at 0640, hoping Bryan was planning to be up. Perhaps he'll turn up. Meanwhile I'll try to spike something useful.

It's 0645 on Sunday. Bryan shows up as I'm summarizing status, and we get a really nice effect with some truly simple code.

We simplify two classes by adding just a bit of capability to another. Still wondering how to write articles after the fact.

Some pairing has been taking place, without contemporaneous writing. I will explain what we have. No, it is too much. I will sum up. Includes remarks on working without a net specification.

An attempt at refining the concept of this multifarious idea we're hatching.

A tiny experiment in Python on my iPad has inspired me to try a spike this morning.

We've agreed not to cater to client-server at all, to the degree we can manage it. As a first start, we've removed the World-Client variant classes and will simply be working with Biots sending messages to the World, and the World sending messages back. We'll see how that goes. I have one concern. Well, one that I care to mention.

We made some progress yesterday, and I'll report on that. Before today's meeting, I am a bit confused about what we should do next. I get a truly scary idea.

Another quick look for something needing improvement.

Secretly, Bryan and I are starting work on 'Biot World', a start at the joint project our Slack has been talking about.

Let's see what else might use a little improvement.

Still looking at that 20 line class. Yes, I think it needs improvement. Am I serious? I think I am.

I think we're nearly done with Sudoku at least for now. Let's look at the code and see what we can say about it. We find an issue in the first 20 lines. Wow.

After a review of notes, we move component looping from one class to another, in seven very smooth moves. I forgot to commit two of them, but it was still quite smooth.

Let's review our notes and see what to do next. Is there a way to wrap this up semi-neatly? Quasi-neatly? Not yet, but progress is good.

I believe that our naked and hidden pairs code was reporting that it had changed things when it had not. That would be bad. Let's see about doing it better.

Before we plug in the new Techniques, let's work on the 'Making App' with a very small Logger. Very mediocre results this morning. Meh.

Let's review our list and see what needs work. I want to try super tiny steps today, just as a matter of practice. (cf. Charles Beaudelaire)

We seem to have working code for hidden pairs. It is not yet a suitable object: more of a working prototype. Let's step back half a step and assess where we are and what to do next. We narrowly avoid a bear bite.

I think we're ready to try to find a real hidden pairs situation and adjust the notes accordingly. I am sure we're going to find an interfacing issue that will be a bit interesting. Includes notes on 'think-squared'.

Soon, dear, soon. We have the ability to set up a test. Let's see whether that sketched Hidden Pairs idea will work. I think there is at least one more stop before we're there, though.

Now that we have our foot in the door with `find_candidates_pairs` tacking a condition function, what would we have to say to define hidden pairs? Spoiler: We improve our ability to test.

As I think about additional Techniques, I believe I need more help from my objects. I have an idea to try out. Well, part of an idea.

Well, the new 'lonely' technique needs better testing and maybe a better name. I really want to do an unneeded optimization. There is grunt work to do. PyCharm earns a biscuit.

If, in the candidates for a given component, a value appears in only one candidate list, then that value must be assigned to the corresponding cell.

I wonder whether it would be that difficult to have constant Component instances rather than creating them dynamically? Kent Beck haunts me.

Yesterday's work useless. Last three days generally ragged. Today, I'll try to be more focused and go for speed. See Kerth's Prime Directive.

Based on input from my betters, I work on a faster way to deal with Candidates. GeePaw puts a word to it. Probably the wrong word. I go off on a tangent and discover profiling. An odd morning, with some interesting discoveries and one nice tiny object.

Having come up with the word 'evolving', I am ready to tilt once more at the windmill. Will I succeed this time? Spoiler: Yeah but U G L Y!

Tomas has been nerd-sniped and is solving Sudoku with Haskell. I nerd-snipe myself, thinking about Haskell, immutability, and updating. Some learning, almost no progress.

The Naked Pairs (NAIAIS) technique seems to work. What should we do next? I feel that we should step away from the brute force solver.

Ron, you keep changing the design all the time! Why don't you just nail down the design once and for all, and move on?

Did you ever look at your code? I mean REALLY look at it? This is going to be good! And it is!

I thought that I had made a misteak, but now I think I was wrong. I refactor to very small methods. Too far? Not for me, what about you?

Well, naked pairs, still, but I've used up that title. Brother Bill raises a question. I think we're OK. Let's try to implement the idea, whatever it is. Result: it goes very nicely.

Still not as interesting as it sounds, but this morning I plan to hunt down some naked pairs. I foresee some issues. And what about that pending issue from yesterday? Results: a bit long, but some shape emerges.

I've found some Python code for Sudoku techniques. I do not like it. But it'll be useful, I reckon, even though we aren't likely to copy it.

Reflection on how things are going makes me think we need to change direction a bit. Can we manage it without rewriting a lot of code? Can we keep all or most of our existing test working? Let's find out.

We already know of one more 'smart' technique that we might apply, but it seems a bit tricky. And how can we provide a 'menu' of techniques to be applied? Is this Big Design Up Front?

Let's fix that reminder test and set up to allow us to select techniques. A bit of progress, and raggedness tells me I need a break. It's artificial, it's intelligent, and it's not AI.

Let's try to put some intelligence up in this thing. Not artificial, mind you, though it will involve code. Spoiler: Works well and we learn a bit.

Tomas provides a clue. Whatever might we do with it? Ideas, experiments, and a decision not to go ahead with the ideas ... yet.

This thing just keeps on giving. I want to check something out. Result surprises me and I'll need to do some more thinking. Got good ideas? Let me know!

Is this a game of Sudoku, or a game of Columbo? I keep finding things to do! Fewer classes, a bit more clear ... but a few more lines of code.

It has been a while since I looked at the Sudoku code. I don't have anything in mind for it, but let's see what we can find just by looking.

I've thought of an object that we probably need. Let's find out. Result: A very pleasant refactoring sequence leading to a design that I prefer. Click to find out why.

What does all this have to do with real programming? We'll begin with last night's FGNO and go wild from there. We mention Iceland, and the age of the universe. Onions. Easter eggs.

I've come up with something that I think will be much nicer for computing the base positions from which to fetch our rows, columns, and sub-grids. A little refactoring does improve things, I think.

Let's review the code and the "project", to see what, if anything, we can conclude.

My theory is that once the sub-grid calculation is added to the Puzzle, we should be able to solve a 9x9. Let's find out.

The trivial test for my initial solver sketch passed. Will it hold up? Let's find out.

If the code agrees with me, I think I'd like to sketch a tiny solver this morning. Let's see if that's feasible. (Spoiler: It is.)

Let's see about getting the column, row and sub-grid for a given array index.

We spoke of Sudoku at FGNO, and my 'failure' with it, and with me, apparently, the failure of TDD, Extreme Programming and all of Computer Science.

I know it's a sin, but I've been trying a chatbot in conjunction with programming. Here's a brief report.

During our FGNO Zoom session, Ken brought up an interesting little problem. Let's play with it a bit. Gets a bit long, but it's really pretty light work. Fun effort, meant as such.

I'm not sure I'm done with this XST experiment, but I've come to some conclusions that I want to set down. Having done that, maybe I'll know what to do next.

Changing the rules a bit, yesterday, limits the richest player to around twice the starting amount. But are there still permanent winners and losers?

Bruce Onder appears with an interesting idea. It does make a difference.

Here's what my little simulation makes me think. Reflect upon the ideas of Richard Skelton and Robert Fitzooth. And maybe upon mine as well.

Let's clean up this code just a bit and then draw some conclusions about programming a thing like this. Clickbait: The technical conclusions are not what I thought they would be.

We recover quickly from a mistake last night, and get a nice histogram. I'm surely reading too much into this little simulation. Or am I?

Let's tune this thing up a bit. And let's try to avoid momentum calculations. P.S. The rich get richer.

I've been pecking away at the little simulation. Here's a report on status. We get some early results: the rich get richer.

"The rich get richer." I propose to pivot to implement a simple but interesting simulation. A good start after the usual trouble creating a new PyCharm project.

Mistakes? Technical Debt? Better ideas? All the above?

OK with that out of my system, what shall we code today? It goes so nicely, until oops.

I'm not out of ideas, but I am out of directions, and my momentum is low. What shall I do?

The swirl that is my life leads me to think about duplicates and such. Very speculative musings, no conclusion. Sort of Captain's Log Stardate 77691.1.

The statistics code is much better now. But a little widget might be just the thing. Turns into a medium-sized widget, but I think it's an improvement.

The statistics code runs, but is written in 1960's style—yes, I DO know what 1960's code looks like—and needs improvement. An interesting series of events with a fine result.

Commonly, when we group data by some criteria, we desire summary information about the groups: counts, totals, averages, and so on. We take a couple of nice steps before my brain is fried.

Yesterday's experiment with `group_by` seemed very successful. What does it tell us about what we're doing and what we should be doing? Bit of a retrospective.

Let's try an experiment, along the lines of my sketch at the end of this morning's article. It goes very well. Very well indeed!

I'm here for another step on the way to the grouping operator. I have at least one new realization going in. More than one coming out. Some code progress as well.

Time to push a bit further on the grouping operations. I don't get far before realizing that I need to break away and try again later. Not great, but good.

A bit of research into the past of Extended Set Theory suggests an interesting possibility for the future, and provides the joy of working something out on my own. Includes some possibly amusing history about how primitive man created such documents.

I'm continuing directly on from the preceding article, to create my XGroup implementation. It may turn out that a break was needed. We'll see.

This morning I'm working toward a join operator, by way of a grouping operator. I have vague ideas, and need some help from my code.

Fancy as my new streaming select is, I think it's, well, not quite the thing. Easily replaced, but do I need to pivot? I surprise myself.

OK, new rule, we're going to read XFlatFile sets into memory. Should we refactor to this new result, or TDD a new class? Let's refactor. Works quite well!

It's 0415 and I am thinking about buffering. I create an XSet with a billion records in it. Python does not sneeze.

The thing about learning is that when we have sucked most of the learning juice out of some fruitful idea, there is often work to be done to get the thing finished. We have at least two of those hanging fruits right now. One of them has an interesting effect!

The Powers That Be have invited me to discuss the risks around this Python XST effort, on the assumption that it is anything other than play.

There's no doubt that we can create sets or set operations that stream their results, avoiding creating large temporary sets in memory. There are issues to think about. First experiment works!

In which, your intrepid author considers times now and times then, assessing whether and how to adjust what we do with XST given the new reality.

A check of our list of ideas leads to discoveries, to key decisions, and to reflection on the realities of software development. Quite a span, as perhaps it always should be. Interesting article reference included.

Ran across this. Rather nice. Then I took one more step. Off a cliff. Fortunately, I didn't look down.

We've been working on calculated fields. Let's see about getting them built into sets. Yucch! I touched a debugger.

Our work on calculations raises some longer-term concerns about large dataset and statistics. Are we in big trouble?

Let's fetch values from XST records for our Expressions. I expect this to go smoothly. It does. We discuss small steps. No, smaller than that.

I have a bit of time, with distractions. Let's see about error conditions in our expressions.

We need to work on assignments and field values. I was thinking values, and then we do assignments instead. That's where the path looked best.

We'll take some steps along the expression path. I'm slightly questioning part of what we have. The path is zig-zag but leads to a good place.

Spikes for the expression parsing have taught us enough. Let's see how we can best move from the spike code into decent production objects. There's one somewhat large issue: symbols. No, two: data types.

Back to the interpreter. Shall we try the lambda thing again, or something else? Lambda seems fraught. Partial function FTW.

We can parse a simple expression. Let's sketch the expression interpreter. Bear gives us a nip, but we have progress.

I think I'll break down and do expressions. I'm thinking a simple Dijkstra-style parser will do the job for us. Let's see if we can find a simple way to develop one.

Suppose we want a set where one element is the sum of two others. What about calculating a scope? I am interrupted and then spot a squirrel.

Somewhat enlightened about how early XSP systems worked, there are a few ways we might go. I need too reflect on possibilities and pick a direction.

Study of some ancient scrolls leaves me thoughtful, and a bit disappointed.

You probably do not want to read this. I'm writing down my thoughts, in the vain hope of figuring out what they are and what they should be. Dave Childs was kind enough to send me some links to articles and other materials about XST. I include them at the end of this article, for reasons. The materials gave me some things to think about.

I was whining earlier about the difficulty of writing tests that assert about elements inside a result set. A thought has come to me.

I want to work on some indexing operations. Along the way I rediscover XFlatFile's existing scope set feature. Just what we need. Or is it? Includes a judicious rollback.

Laurent challenged me to find a better, more elegant formulation for getting the correct re_scoping set from a provided renaming set. I thought I had it. Then I thought I hadn't. Then I thought I had.

We have a long-form cardinality method. Let's use the len function and require it as part of the implementations.

Let's look around and see what we might do. I'll even make a list. Jira is an abomination upon the land.

I have received a bug report! This is great news! Someone is paying attention!

Putting a specialized rename into our flat set showed us that the symbol table there is quite ad hoc. Let's make it more like a set. (Turns out: no.)

Since the Flat sets know their field names once and for all, we could use a better rename that doesn't copy the data. Simple enough, rather nice.

If there was a kind of set that was expressed as a function, we could possibly pipeline operations, reducing memory impact. Is that possible, and is it a good idea? So far, maybe not.

What if a function IS a set instead of returning a set? This might be significant.

We try and succeed in implementing an XFlatFile that refers only to a subset of the file. This is a big deal!

I'm working on the idea of an XFlatFile that only reads a defined subset of the file. Am I working without a net? Not really.

Plus wasn't the right operator for union. Let's update that and then a few other operators.

I had thought that I'd work on the flat data. My thoughts led me astray, to a glimmering of a possibly good idea. So I'll just code something cute to finish the morning's work.

Thinking about rename in the Flat implementation leads to discovery of an interesting defect, and some thinking about use of the powerful generality of set theory.

In an astounding flurry, we are going to build a rename operation.

Childs has defined two "re-scope" operations. Let's see if we can implement one of them, and if we're glad we did.

We'll start with a simple removal of the requirement for implementations to implement `__contains__`. After that, we'll see. (And that's not what happens.)

In your absence, I made a simple but significant change. I had an interesting idea. And an important observation. And more.

We make some progress on our flat files, but progress is slow and there are a lot of words here. Best skim or skip?

Let's see about getting set creation sorted. We need to be better able to create sets with any possible base implementation. Deep confusion ensues.

To process flat files, we want to avoid leaving a file open, and we don't want to open it a zillion times. Do we have to invent buffering? Perhaps not.

Our experimental tests one flat records look good. Let me report on my off-line work, and then let's see what's next.

Let's get started on a flat-file-focused form of set. We make a bit of progress.

I want to begin by thinking about storage: how do we best produce specific memory / file formats? The article turns out to be pure speculation, but perhaps useful speculation.

Having prepared better than we did yesterday morning, let's proceed with wrapping our `frozenset` with a class of our own.

Let's have another try at wrapping our `frozenset` in an object that will work for us. Things go much better ... so far.

I make some useful initial observations, and then, well, I crash and burn. And mix a metaphor.

I think that this morning, I'll take a small step toward having more than one implementation of a set's data.

If I'm going to get serious about this Extended Set Theory thing, a tiny bit of design thinking seems to be in order.

It is 0253 hours. I have a report and another report.

Lets do `project`, as in projection, as preparation for trying a generator approach to set expressions. This part should be easy.

There's a thing I want to do with this XSet stuff, and I don't quite know how to do it. I need to better understand iterators and generators.

In which, we report on a nifty little thing, and then, well, I don't know yet what I'll do. Some concluding remarks on what it is that I do here.

In which, I show you what I'm dealing with, and mention an insight.

In which, I realize that I have made a mistake.

Let's see how we can select records from an XSet, using the `restrict` operator.

I propose to push a bit further on the use of Python frozenset to do a little Extended Set Theory. I mention symmetric difference!

Some random reading, and the messing about that I've done in the FAFO series, leads me to want to explore Extended Set Theory in Python. I do not expect it to be useful but it might be interesting.

A little planning on what I might like to do. No code, just thoughts. Wow, "slug" has a lot of meanings.

Joy projects. Impact. Transclusion?

Thinking about simplicity, generality, abstraction, and the FAFO data. A tiny but possibly important insight.

Zoom report. Simplest thing that could possibly work.

Too far is far enough. Not quite too far isn't.

A "database" to work with.

A Pythonista experiment makes me think. Time permitting, I'll build some files.

Having given Hill some bizarre advice last week, I propose to "Fool" Around and Find Out some things about the idea.

Wherein we consider some advice given to GeePaw Hill at a recent FGNO session.

In the unlikely event that I hit the saucer, it is supposed to display the "mystery score" that applies. I think we can do that.

We continue working on the game's beat sound. I am faced with a dilemma.

The game lacks the terrifying beat sound that characterizes the arcade game. Let's put it in. Begin with a mostly unrelated question.

Despite a lot of musing about the Situation, I've not made enough progress to spike anything. What shall we do instead? A tiny improvement?

Now for something completely different!

I only just realized the name of that bear. But mostly, musing about the Situation idea.

Let's see about this explosion mixin. Now that we've sat on it for a few days, so the glitter has worn off, do we still love it?

I think there's maybe one more explosion up in this program. Let's see if we should add it to our mixin.

There's at least one more place where the ExplosionMixin could be used. Should we use it? Let's find out.

Are mixins a moral issue, or simply a useful tool?

Just one tiny improvement.

The morning goes in a completely different direction than I expected. A good direction, though.

Continued: One of Kent Beck's perceptive Rules of Simple Design is the one about expressing all design ideas. Some code up in this thing bothers me.

One of Kent Beck's perceptive Rules of Simple Design is the one about expressing all design ideas. Some code up in this thing bothers me.

This morning I thought we'd start partitioning the 3 Player classes. The situation suggests otherwise. Some simple refactoring. It's all good.

Dude, did you ever look at your hand? No, I mean really look at it?

Let's look today at three classes that are similar but different. Make similar code more similar. Soft, gentle, geek joy.

Today we're going to resolve the issues with invaders getting low enough to end the game.

A report on a PyCharm Live Template for starting TDD. Some experimentation. No yippee.

I look back at what one might have learned along the way here. Joy: highly recommended. Find yours.

When the invaders fire on the robot, it does not explode. When it gets a new batch of invaders, they don't fire on it. This cannot endure. Results: good. Code: OK.

Can we figure out a decent way to improve the attract mode? Should we make the robot player a better player? Perhaps not.

There are issues. A long, slightly fruitful refactoring. A much more deadly attract mode that plays better than I do.

Trying to keep the Driver-Player simple. How well can I manage that?

Sometimes I get ideas that are really tasty but impractical. Let's try something practical.

I have an idea for a step toward attract mode. I plan to try part of it.

Let's at least deal with the invaders falling off the bottom. Maybe a first step toward a better attract mode. Pretty ragged.

Today, just a simple Game Over screen, so that we can at least see our final score.

I plan to implement a Game Over screen soon. The first one will just display GAME OVER. But could we build a somewhat smart attract mode? One that learned to play the game? Let's think.

How many ways can we think of to do a thing? How can we decide among them? CW: Ignorant Savages.

We'll make sure that our tests check the production generator function, but mainly I want to talk about small steps and TDD.

Bill Wake suggested a generator function for my invader starting heights. I think this will be a keeper.

Will a tiny object help clarity in the InvaderFleet setup? Let's find out.

Today I propose to make the invaders advance down the screen. I have the details. I am not entirely happy with the result, but it is solid.

... the thing I call TDD might not quite be TDD. Also some speculation, and some other speculation. Pure musing no code.

I think today we'll deal with the possibility of running out of invaders. Today we bite the bear. Take that, bear!

Let's find something to improve the program, but small enough to be suitable for an early Sunday morning. I think we did something right!

The Invaders game, while playable, isn't quite as done as it might be. It's well past time to be adding some capability. We briefly discuss the point of software development.

I think that I don't quite like how the Invaders deal with the edge of known space. Let's explore. Result: I am pleasantly surprised.

I put in a new method yesterday. I'm not sure if it was a good idea, potentially good idea, or sheer waste. I love changing code.

I have in mind a few small things that would like to have attention. Are they worth it? I think so.

We can remove some duplication with inheritance. One pythonic way is with a mixin. Let's look into that.

With the new ability for Sprites to detect collisions, let's start converting classes. We should be able to do them one at a time.

With a couple of classes using the Sprite, it seems like time to see if we can put enough useful behavior on it to make it more desirable to move to it.

Either I was less intelligent than usual, or there is something tricky going on here. I'll proceed with due caution.

I will share with you an intuition, a guess, about where this Sprite thing is going. Then I'll plug away.

Today I plan to improve the Sprite object to handle animation. I am optimistic about this.

Today I'll try to gin up a little object containing the mask, the rectangle, and the position, to see if it makes things better. I am hopeful.

Design Thinking: There's this notion of "encapsulation" that I've heard about. And "cohesion"?

What general notions might we draw from the past few days' work? What do you see that I do not?

We'll review the saucer code and improve it.

Saucer is still too complicated. I had an idea yesterday at close of session: a helper class!

Drilling down was useful, I think, but let's take a look around for new code signs. We wind up working on names. Again.

I think I see something that would improve the InvaderGroup logic. Let's find out.

Let's have a look at the new code for invaders and edges, see what it's telling us, and do something about those hundred-plus calls. Bear bites man. Man survives.

I promised to throw this spike away and do it over. Can we talk about this? Includes words like 'folderol' and 'bugaboo'.

Let's try a spike that may lead to an improved version of our invader fleet logic. I promise to throw it away.

A very strange session. Two hours of reading and thinking, one very simple change adding an enum, no major improvement. Wasted? Or valuable? I'm not sure yet.

I propose to identify and discuss the things I see in code, what they make me think, and perhaps a bit about what I might do about them. This does not go as I expected.

I've run into a small issue with the Sounds object. I think I have a solid idea for it.

Working on sound, we encounter an interesting refactoring, done in a very zen-like fashion. Small steps, add duplication until it resolves. This was really quite nice.

I have a somewhat more expressive way to, well, express what we did yesterday. Do we prefer it? Let's find out. Short, and sweet.

I propose to remove some if statements today. Why might we do that? Do we like the result? Readers may disagree. I might even disagree with myself.

I'm pleased that Invaders has been implemented without framework changes. And I see what I think is a desirable change. I learn otherwise.

I want to talk today about Programming by Intention, a notion I learned from Kent Beck and Ward Cunningham.

Seeking something to do, I'm back on my Invaders [DELETED] again. I do tidying. It comes down to joy.

GeePaw Hill and I both noticed something odd about the Wordle words. Is it an inherent property of the game, chance, or intelligent design? Spoiler: It's neither!

Herein, some comments on what I've learned playing with Wordle.

I've thought of a streamlined way to get the expected information values from the file data, and want to try another shot at parallelism.

I can't explain why, but I've decided it will be interesting to try the information theory ideas I've found on line.

Convinced that I can't make generating the SolutionDictionary fast enough, I'll explore pickling it.

I think yesterday we were limited by pickling. Who knew? First try: Debacle. Second try: Can't work, don't even try.

Today I want to try something new: concurrency. Includes: Thrilling Video.

I'm struggling to keep the shape of the solutions dictionary in my mind. Therefore I need something simpler.

Let's save some test time by saving some data. And let's look at the data to see what we can learn naively. Spoiler: I quickly ditch the caching idea.

I'm having trouble coming up with a real plan here. And I think I've squeezed everything I can out of `score`. I borrow an idea from GeePaw Hill.

I suspect there's a mistake in my scoring. We do some timing. We struggle for an idea. We resort to some bit twiddling. Do not read, that's my suggestion.

Trying to do 300 billion operations makes me think I should take a new angle. I need a better idea, or a computer that is 1000 times as fast as this one. A better idea may be possible ...

A bit of study tells me that my scoring algorithm is wrong, although there seems to be some debate about it. Then I have to figure out what to do next. I burn an hour of CPU time.

Our Tuesday evening Friday Geeks Night Out Zoom Ensemble is getting sucked into Ken Pugh's work with Wordle. I have caught the virus and am going to start a new Python project.

I have yet another idea for how to get rid of the conditionals in the saucer code. This one might actually be pretty decent.

I have an idea for how to get rid of the conditionals in the saucer code. It is a nasty idea. I must try it.

Time to look at the Saucer and see if it needs some improvement. I feel sure that it does. A very nice refactoring sequence appears.

It's Sunday morning and I have a little time to play. Let's see what's left for the Saucer.

Let's see what's left for the saucer and what we can do. It's late Saturday morning: maybe we won't do much.

We'll continue with the Saucer. We'll look at what's left and pick something. Includes thrilling video.

Yesterday I was running faster than my feet. Let's see how the Saucer code looks and how to improve its tests and the code itself.

Let's see about doing the saucer. How hard could it be? Well, not hard, but ragged and chaotic. I moved away from my A game for some unknown reason.

I think about screen layout. I look at the list of things to do. It's the Jira Trap!! It all seems so reasonable ... until it isn't.

My keyboard tray Jira is getting too messy. I'll clean it up and go to a much more high-tech solution. Also: a tiny tweak to screen layout. Also: robots

There's some duplication between the BottomLine and Shield. Enough to fix? Let's have a look. Outcome: This goes ever so nicely! Sweet!

I found a way to damage a Surface, given a Mask. I don't exactly like it, but it works. Now what?

Yeah, let's do the bottom line. Might be just the right size for the afternoon.

I think there are very few things left to do with Invaders. One of them is scoring.

More waffles, about the tensions between design alternatives for the Flyers. What if we were to open the doors as widely as possible? I think this is my last waffle on this topic. I like the outcome. Today.

I gave abstract method a chance, for almost 24 hours. I hated changing all my classes to implement all those pass methods. Let's try a different dispatch. Waffles?

Now that we have this metaclass, and now that we have this decorator, what shall we do? The answer may surprise you.

Let me explain. No, it is too much. Let me sum up.

We continue learning decorators using tests. Our simple decorator doesn't handle parameters in the wrapped function. Lets figure out how to do that.

Never heard of him. Let's learn about decorators, using tests.

The Python "decorator" is less bizarre than metaclasses and might be just the thing for our needs. Let's try one.

There are surely ways to provide my `ignore` feature without using metaclasses. I can think of one. Maybe it will help me think of another.

Having found a way that I think will work, I'll try again today to install the 'ignore' capability. Hamsters. And success!

Today, I plan to install the new metaclass with the `ignore` feature. Result: Bears discovered deep in the bag of tricks. They bite. Later: I know what caused it.

Today, in the spirit of meta, I work on a metaclass for ignoring methods. I start on Wednesday and finish on Thursday. It's scary weird.

What shall we do today, Brain? The same thing we do every day, Ron. Find something interesting to do. Things get very meta ...

The Invaders team has encountered a troubling issue, and have been making some troubling decisions. We need to explore this and deal with it at its root. Spoiler: It's not the programmers. People over process.

Let's do ReservePlayer. It has essentially no behavior. We'll TDD it anyway, and will be glad we did.

Thinking about how we'll replace a destroyed player has led me to a strange idea. Perhaps too strange, yet fascinating.

The words "time capsule" popped into my head last night. Have I told you my favorite thing about this program's design?

Bill Wake's comment suggests more use of the new Masker. Looks useful.

In which, a small object helps improve our code.

Part two, following P-247. Another idea. And we still have more opportunities to improve! Wait, SQUIRREL! Two of them!

In my quest to spend way too much time on ImageMasher, I have another idea. I should also mention why this exercise is a good one: changing code is our job.

Let's take a look at the ImageMasher. We'll see how far toward perfection (or lily-gilding) we can push it. We go a long way—and at the end I think I see still more that we can do.

It's oh-dark-thirty but I think I've got the answer.

An early idea got me up, to get it down, as it were. Too interesting for me to go back to sleep. Yes, I am strange.

I didn't see it on my drawing, I didn't see it in my code, but then I saw it in the code in my mind. The lessons today, oddly, are about dozing, and estimation.

I believe I'm close to understanding masks well enough to build a little object. Another test or two and then I hope to try something. Chaos may or may not ensue.

Before I try to improve the way the Shield adjusts its image and mask, I feel that I need a better understanding of how things work. We'll use tests to learn and record.

Some reflection, and an exchange with Rickard, makes me think that my lovely little Tasks object isn't as great as I initially thought it was. Let's think, code, think, and learn.

Let's do some tasks, now that we have the Tasks object. We'll see how we like it.

Not my ideas, mind you. Two good ideas from Tomas set me on a course for last evening and this morning. Are there rats in here?

Let's see if we can add lightness to our reminder facility.

My timing defects have caused some thinking, some of it mine. There might be a better way. (This is long, because there's a lot of design thinking. Then some rather interesting doing.)

There's a second "timing" defect in Invaders. This one is harder to forgive. Mea culpa. Plus: At least one other defect. And I allowed myself some fun writing this one, too. Same as it ever was.

Let's clean up the shields code and improve the damage. I've found a missing piece, the explosion part. A rather nice refactoring sequence ensues.

Let's clean up the shields code and improve the damage. I've found a missing piece, the explosion part.

It's 3 AM. The power's out, the phones are down. Of course I'm going to program a bit.

I have the facts. Let's draw four shields. Then shoot them a bit.

The Invaders game has shields, four of them. They take damage from invader shots, but are not destroyed in one go. This will be interesting. What do we need and what are some small steps?

Let's start transitioning away from inherited `interact` methods, making them abstract as originally intended. I'll try to devise a sensible way of proceeding,

Let's explore last night's matrix idea. There's got to be a pony lesson in here somewhere.

Last night, some topics came up that I'd like to consider a bit this very early morning.

If I'm right, which assumes facts not in evidence, this next step is going to be surprisingly easy. This often happens. There may be a reason.

I had an interesting realization about the shot patterns. And we have a hanging commit, some broken tests, and more to do before we are done.Things go well. Thoughts on small steps.

Let's find another small step toward invader shots. Maybe even more than one. Very long, I'm not sure why. And no commit at the end. Afternoon distractions. Not delight, just distractions.

Invader shots emanate from invader columns, according to a pattern. How are we going to do that?

Everyone needs them. Let's make that happen. Then, let's explode some invaders.

I think first I'll have the invader and player shots destroy each other if they collide. I had hoped for more. This caused enough trouble. Mostly resolved, I think.

I think today I get to start on the invader shots. How much of the original game's pattern must I follow? Probably it's too soon to ask. Squiggles!

There's reason to believe that there's an object in here. Let's bring it out. I feel I picked a poor path. How could I know?

At least two collision issues face me. One is how to stop the shot after it hits an invader. Another is that I see an object trying to be born.

Let's see about how to detect collision between the invaders and the player shots. I think we want to do actual bit overlap.

In response to a question from Bruce, I find myself looking askance at one of my darlings. Should I kill it?

We have a start at player shots. Let's get one on the screen .. and then off the screen.

I think I'd like to try the player shot. Names are becoming an issue. For once I do the right thing.

It's time to make the game look a bit more like a game. I'd like to think briefly about what to do and how to do it.

Having used the BitmapMaker in the game code, I envision a better way of using it.

I think the bitmaps are ready to be moved into the Asteroids-Invaders repo. I hope to actually use a couple of them in this session. Success! And an amusing mistake.

I've been pecking away at making the bitmaps for Space Invaders. Let's take a look at where we are. Gross ad-hocery and a lot of pasted data and bitmaps. Not very interesting, even for me.

There may be room for more refactoring in the fleet/group area. What even are those two objects? New CSS, consider clearing browser caches.

Let's continue to look at InvaderFleet and see whether some handy little objects might help us out.

It seems to me that InvaderFleet may be asking for some refactoring. Let's start with some thoughts on TDD, and a look at the tests and code.

I would really like to move this game along a bit. But there's a matter of scale that needs attention: the reversal points. And that fills the morning.

Let's continue with moving the invaders. We have some issues to deal with, and for at least one, I have no solution in mind. Lots of thinking tells me there's something funky in here.

I believe that I've made a mistake. This will not be my first, nor, I fondly hope, my last. CW: Contains brief Jira abuse.

It's time for a README file. Well past time, to be clear. And I have an ulterior motive, which will become apparent in due time.

Part of a short series on design, static vs dynamic languages, god objects, and our ability to understand the code.

Let's take the next steps to, um taking the next steps.

Bruce gave me a very nice idea: Bumpers! I think I'll try it.

I've decided to extend the Asteroids program to include Space Invaders in addition to Asteroids. I expect this to be—well—not easy but not too difficult.

We've managed to import some bitmaps and display them. It's time to start sketching and executing a plan. Then I ask myself a hard question, leading to a complete change of direction!

We do a quick bitmap experiment, and then create some alien surfaces from the original Space Invaders arcade source code.

Further setup for the record. PyCharm pleases me.

Today I plan to set up a new Python project. This one will be a Space Invaders replica. I'll say a bit about the idea, but this is mostly just a record of how setup went.

Somehow I am enjoying working on, refining, polishing this Asteroids game. I don't want to stop. I have at least two silly features in mind. And, are there still lilies to gild? We discuss inheritance. Basically done?

Is this program as perfect as I can make it? Is there anything left to do? When your best idea is spinning asteroids ...

Tomas Aschan inspires me to try an object. I don't think I'm going to do exactly as he said, but when this works, he deserves much of the credit. If, perchance, it doesn't work, it'll be Chet's fault. But it will work.

What if we made all three `draw` commands look alike?

On our quest to improve SurfaceMaker right out of existence, let's try a LinePainter object to replace it. Except that I change my mind almost immediately. Notes within on hints that I wasn't working ideally.

Now that we've improved SurfaceMaker, can we improve it all the way to nothing? Let's find out.

We've improved the SurfaceManager a lot. We'll do a quick review of that, and then see what we've missed. Why? It's good for us and for our organization. Late note: Ron was too clever.

I've implemented the SurfaceManager to allow callers to specify extra room for fat lines. That was not a good idea.

At the time I worked out how to draw the game objects, I was new to Pygame and all its works and all its pomps. We deserve better. Refactoring FTW!!

The screen objects are too big for the amount of screen space we have. We need a global change of some kind! (Turns out to be disappointingly easy.)

We'll start with some philosophizing, and then we'll do a review of the saucer's missile-firing logic. Fun is actually the point.

I have no particular goal in mind this morning — yet. We'll look at our recent work and then beyond it. My initial concern: Aliasing.

I'm going to take another try at improving the ShotOptimizer code. Not because we really need to, but because we want to learn how to make code better. That's my story and I'm sticking to it.

I see the issue and fix it. An aliasing issue. I haven't had one of those for a very long time. Still no committed code change but some good ideas. Next time?

It's 0430 hours, commonly called oh dark thirty. I have a desperate need to clear my mind and get back to sleep. I try some things and settle on none. I learn some things but no net code change.

This morning PyCharm and my code rubbed my nose in the notion that a "static method" signal may mean that the method in question really belongs on some other class. Let's explore that idea.

Today I think it might be fun to extract a SafetyChecker class from ShipMaker by refactoring. First I get a better idea, and then the code tells me what it really wants. Fascinating!

Just for fun, I add a cheat code. Might not be my last one.

It's funny how thinking about one thing can give you an idea about another thing. Just a little fun today.

OK, let's see if this baby will fit where we intended it to fit.

Because I injected a defect into my two-player game, and because it could be better anyway, let's make it better.

After all that happiness, I realized that free ships go to the wrong player in the two-player mode. Bummer. In fact: Dammit!

Let's review how we added a two-player mode to the game. Let's look at how it was done. Frankly, I am pleased. EXCEPT: A Defect!!

If things go roughly as I expect, we'll have the two-player game today. Sometimes things do go as I expect. It could happen. It DOES happen!

Yesterday, an idea. Today, an experiment. Your intrepid author is optimistic. Things go very nicely.

Let's think about a two player alternating game and how we might do it. A bit of design thinking seems to pay off.

I think the coin test is better than it was, but it isn't what it could be. Let's do better, just for the practice. I surprise myself with a challenge.

I thought this morning that I had broken the game. Why am I even doing this seemingly useless changing? How do you get to Carnegie Hall?

I'll just have a look in and see what might need a little tidying, then, shall I?

Zoom report. I notice a thing. What is to be done about it? Something nice. Repeating the Faulkner quote from yesterday.

Sensible thoughts lead me to wild speculation about the future of this tiny program. Who knew? Then, I create something nice: a Transponder!

Let's continue the scoring improvements, with a little help from our friends.

Working with Saucer has me thinking that scoring is unnecessarily complicated. Let's look into that. Isn't it amazing how much a tiny program like this one can be improved? And I didn't even try to do a poor job.

Saturday: Remove unneeded abstract method. Discuss design. Sunday: a nice refactoring series.

As small as this program is, it shows us examples of issues that arise in larger applications, and suggests similar changes to those we'd make in the wild.

I really don't like the fact that I am either too dull or too lazy to derive the quadratic targeting calculation. Either it goes, or I do, and I get to choose.

I'm just going to look at random bits of code and see what they suggest to me. Watch me if you care to.

Bill Wake gives me some thoughts about a static method. We'll look at that, and see what else may need a bit of improvement.

Last night, I showed my friends two largish methods. Soon, everything was different.

This morning, I woke up thinking something was broken. Fortunately, I was mistaken. Let's fix it anyway. Also, thanks to a reader!

This afternoon, I notice something that could be better. Let's see if we can find a bit of improvement.

The final of four articles covering a single refactoring session. It has gone ever so nicely.

We continue a long refactoring session. It goes so smoothly that it all happens in one stress-free morning.

I begin a long refactoring session. I'll split the article another time or two. I am a merciful person at heart.

Again today, I plan to make the necessary adjustment to missile velocity to improve targeting. Again today, I have an idea. (First of a few articles all reflecting one morning session.)

I've left in two tests that aren't testing anything, and I still want to improve targeting. Let's see what we can manage. (Answer: Not much. Final thought on story estimation.)

This morning I discover that the code doesn't do what I thought it did, nor what I now want it to do. Inching toward better.

The new targeting code seems to work, though I could not derive it. I want to refactor so that it makes more sense, and I have an idea for a bit more testing.

I get some good advice from a reader (!) and ten (unrelated) consider a demonic idea. I lift a solution from the Internet. Some nice little refactoring. A few tests. Saucer is deadly. Could be more deadly.

The small saucer should always target the ship, while the large one targets randomly. Let's see how we might manage this. The Gunner does know the saucer ...

I think today I'll put in the small saucer, because the game is already too hard for me.

Let's begin by getting rid of the Explosion Flyer, at least the Flyer part of it.

We think about our design, do a feature, recognize a potential concern. Not what I planned, but that always happens.

Must think about, maybe spike about, an idea from GeePaw Hill. How pure do I want to be, on what dimensions? In the end, "No!" and I'll tell you why.

Observations from Rickard. And let's remove some Flyer subclasses. I still think I've gone too far.

SaucerMissile must go: it is not bearing enough weight for the trouble it causes.

A Mastodon exchange with Rickard makes me wonder whether this program violates Kent Beck's "Rules of Simple Design". I need to think about this.

I think I've gone too far ... I discuss, speculate, wonder, and do not as yet know what to do. Ideas welcome, as always.

At least I'm trying ...

Yesterday's experience causes me to question a central design notion.

Last night, Hill observed something notable. We worked on it then, and I'll do more now.

Looking at Game, and it seems we can improve quite a bit. Great outcome, nearly perfect!

Let's go after Fleets and Fleet. There's too much there for what we need. And, perhaps, too little. Discovery: I like it!

What shall we do now? Think about splitting Gunner? Discover something different in there? Create a debug keystroke? Why not all the above?

I am slightly irritated by the fact that my lovely Gunner object would really benefit from an additional change.

OK, lily-gilding aside, what are we really doing to do with `nearest`?

I'm going to do the tiny object for the `nearest` code. I just want to see how it looks. Talk about gilding the lily.

I had an idea last night as I was dozing off. If I can remember it, I'd like to try it out. This turns into a long series of revisions of about ten lines of code. Fun for a Saturday.

As a lark, I plugged in the Gunner. Doesn't seem to work. Let's see what's up.

I've received a PR or two from Jani, and then on to more work on Gunner,

I am trying to do little things in a house full of banging. I found something possibly worth thinking about. And maybe I go off the rails. I'm not sure.

A toot from Jani led me to see the defect allowing ships to shoot themselves down. The question is what to do about it.

We are getting a new roof today. Might be hard to concentrate. Fortunately, I try never to need deep concentration anyway. Shall we work on Saucer today? We shall. (TDD really works nicely here.)

A couple of small changes, then we'll see what's next.

I did a bit last night. Let's see if we can finish the HG this morning. I bet we can, but then, I read ahead in this article.

Let me do a little background TDD here, see what I come up with.

I need all the help I can get playing this game and I'm thinking I'd do better if I could shoot down the Saucer's missiles. Also, some thinking, and hyperspace recharge cycle.

We want the game to start in "Attract Mode". Should be trivial. Shall we do a Seed? No, something more fun. Also: I make a mistake. Not the first time, just the most recent.

Jira is the name of the area on my keyboard tray where the yellow sticky notes live. It's getting messy. Let's see if there's anything on there we can scratch off, or if all else fails, actually do.

The Game knows the objects that need to be loaded into the mix to start the Game. Let's fix that up.

A Timer-related idea. I have a little time, let's try something. It goes very nicely, I think.

No, I mean REALLY look at it. Did you think I was finished with Thumper?

Did you ever look at your code, man? Like, really look at it?

I think we should break out the thumper logic into a Flyer and simplify Fleets accordingly.

This morning I have concerns about the order of events, and what they are. Let's see if we need more clarity there. It goes well. Important footnotes.

This morning I thought I'd clean up Fleets a bit. Is now the time for that?

As usual, what happens today isn't what I planned. I recognize a design issue, implement a very interesting test, then generalize what happened to consideration of real teams. Watch how my thoughts evolve.

We need a GameOver object and a Quarter object. Let's try one or both of those.

I think there's just one more smart Fleet to remove and then we can greatly simplify Fleets and its interface. I wonder what other specific Asteroids notions may be lurking in the upper levels.

I think I'll move to replace another Fleet subclass. People I trust are tired of Asteroids. I briefly address that concern.

While I believe that my preparation work the last few days has been valuable, it doesn't feel much to me like real progress. Today I want a better feeling. And I get it!

Some thoughts on tests and code, inspired by shipping a defect and by ideas from Rickard. And then some changes. I have a nice one in mind.

I think I can do better than I've done with the Fleets object. Let's think about it.

Let's start with a question from Rickard, and then have a look at the Fleets / Fleet setup, to find one or more small steps toward our desired design. ALSO: Big mistake! Released broken game!

Let's see if we can reduce accesses to the specialized lists in Fleets. As so often happens, the next step isn't in the direction I expect. That's OK.

I think I'll start by counting missiles in the Ship and probably Saucer. Then we'll see what's next. The thing is to keep stepping toward the larger goal. Some interesting [mis-]steps.

What additional special objects do we need, and how might they work?

Let's put the full interaction protocol in place, so that more of our special Flyers can operate.

While sitting in a mostly boring on-line session, I'll do some small safe changes.

I am going to do a thing, and then another thing. Don't tell Hill about the other thing.

I am oddly without a plan this morning, even my tentative sort of plan. Be prepared to read my sort of thinking. I hit a few bumps but not major ones.

We make more small changes in the direction of independent objects interacting to make the game emerge. Let's experiment with full interaction.

I'll do a small change, then see what comes to mind. As long as we keep moving in roughly the right direction, we're good. Thoughts on small steps.

As I move toward the decentralized model, I need some thinking about next steps. But first, an interesting test.

The double dispatch is doing its job. Let's see about cleaning up the references to fleets and whatever else comes to mind.

-ralization. Just a picture of the relationships of some of the objects to start. Then a question: a world record? Guinness, where are you? And then: progress!

Some detailed thinking on how to refactor to a decentralized model. With any luck, some starting code. But I do feel the need of the thinking part.

I really liked the "decentralized" version of Asteroids that I did in Kotlin. Thinking about doing it again, in Python. Refactor to a new design? Why not?

I've been perusing the ancient scrolls, i.e. the Github repo of the original asteroids code. Some notes on what I think I understand so far, then some code. Repeat. Success!

Let's put in some more sounds. I anticipate little trouble. Even here, we learn some interesting lessons.

TIL that I had my speakers swapped left for right. And how to do stereo in pygame.

As one would hope, sound generation in pygame is pretty simple. I managed to work out the basics all by myself. Well, myself and the entire Internet.

Let's see if we can make hyperspace more dangerous.

I need another distraction. What's in "Jira"?

I need a distraction. Let's look for one.

We'll continue plugging in the MovableLocation, but I think it may need a better name.

I want to while away a little time. What can we find that's right-sized?

What if there was some sort of Position object?

We want to get rid of the GFragment class. To do that, we have to get a little head.

While I am OK with the subclass design, I think we can do better. Also "Replace polymorphism with data."

Just the before and after versions of the refactored Fragment classes. Lurvely.

I want to take a look at the explosion, especially the draw method and see how we can clean it up. Many many tiny steps FTW!

Today I plan to add gold to the gilded lily, in the form of still more enhancements to the Ship's explosion. Unjustified, but I plan to be amused by the result. And I am.

We have some rudimentary fragments. Let's make some better ones. I spend ages tweaking numbers.

I almost always have fun here, actually, but today let's explode the ship. That should be a good exercise for the Fleet-based design.

I have some loose end notes in my keyboard tray Jira. Let's have a look at some of them.

I learned something new, and apply it. Also I have an idea of my own. Will wonders never cease!?!?

Thinking about some design issues, some good, some maybe not so good. Seven footnotes, none useful.

We do a bit of review of the code today, and we find some nice improvements.

We'll finish up our refactoring of the checking methods down into Fleets and lower. Quite a few odds and ends, none of them difficult. A noticeable improvement to Game.

It's afternoon and I have some distractions. I'd be wise not to try anything, but maybe I can find some tiny safe steps.

We must be pretty close to done in our quest to move responsibilities down to Fleets, Fleet, and flyers. Also some generic Python thoughts.

Let's move some more Game responsibilities closer to where they belong. (It goes better this time!)

I was off my game yesterday, and want to do better today. I can't be smarter, but I can go slower. I think that, plus experience, will serve. (I still manage to get in trouble.)

Let's push more behavior down into the objects. There's plenty of room at the bottom. (I nearly interfere with the canine, but finally make a little progress. Don't read this article.)

Some of what I did last time needs improvement. This is no surprise, but, really, I coulda shoulda woulda done better. I forgive me.

Are there still easy ways to make use of our Fleets and Fleet classes? The remaining cases may be a bit more difficult. "Repeat, not quite the same way."

There isn't enough simplicity in here yet. Let's add some more.

Colin Chapman's motto at Lotus might apply here. Let's see if we can simplify this code. That will help us add lightness, I think.

I am concerned about an aspect of the design which is inviting mistakes. How might we address it? I surprise myself with a much simpler change than I had expected to make today.

In for a penny and all that, I do the Ship's spawning Timer, somewhat the same but slightly different. I mention a Fundamental Learning.

Now that I have my nifty timer object, I want to use it. Is there a rationale for this? I'll find one.

A test suggests that calling a method from the Timer works just fine. I confess that I find it a bit hard to grok at first.

Features are important, but I learn more from code review, so let's see what we can see. Timer object: Ron does not kill his darling.

There are things not to like. There always are. Let's find some and improve them.

After Hill's good advice yesterday, the Zoom group last night came up with something even better.

I don't know why I needed a hint for this test, but I'm glad to have had it.

The Saucer missile should usually be random, but sometimes aimed. Let's see about aiming. (It goes very smoothly, but I'm a bit light on tests.)

In the unlikely event that I shoot down the saucer, I'm supposed to get points. Let's make that happen.

The saucer's missiles just emanate from center screen. Time to fix that. I'm not sure how to test it. Oh, wait, I have an idea.

I kind of spiked something. I apologize.

Looks like it's time to deal with missiles and the saucer. It fires, and the ship can shoot it. Which should I do first?

My browser was open to the `random` page, and for a moment, my mind was open too.

The Saucer is a saucy little minx. Let's add some more sauce.

Continuing the saucer implementation in a second contemporaneous article, just to spare your eyes.

I remark on some things I learned from Rickard, and then get started on Saucer. I'm so successful that I had to split the article into two to spare the reader.

Let's see about pulling collision logic off into its own class. Should be easy, he said...

I may have casually been referring to the yellow sticky notes in my keyboard tray Jira as "stories". That's not consistent with my classic advice about stories. And my first-ever pull request!

Today I'll keep moving things into the Game object. Probably boring. One Learning: the current_instance trick was useful. Mentioned at the top for your convenience.

I'll just peck away at moving top-level fuctions into my game class. Tedious unless I get a clever idea. Very boring, do not read.

I think it's time to start moving the main loop code to an object. Very rambling and ambling flow this morning. Lots of thinking, small steps. One roll-back.

OK, let's do collisions differently and see what we think.

I'll pick something off the yellow sticky-notes Jira on my keyboard tray.

Let's see about displaying the available ship count, little ships in a row.

I've done what I intended with the billiards diversion. Let's see what we need here in Asteroidsville. Just small stuff. PyCharm impresses me greatly today.

Rightly called on my B.S., I strive to improve by running some timing tests on this tiny patch of code.

I'll point you to a fairly famous anti-clean-code video screed, comment on that, and explore the efficiency, or lack of it, in our little billiards program. I notice something surprising. And something important.

Rotation of vectors isn't second nature to most folks. Let's describe how my little Python billiard ball reflection program works.

Today let's review the code and improve it a bit. I think PyCharm can help with that. Same refactoring, four times!

For the next day or two, I'm going to do a little exercise on the game of billiards. Very simplified, of course.

We should probably keep score. Shouldn't be terribly difficult. Just some text ... how hard could it be?

Let's add the help messages to the GAME OVER screen, and, time permitting, work on quarter insertion. I expect the first bit to be mostly tedious.

Let's clean up startup and maybe we can come up with a finite supply of ships and maybe even GAME OVER.

I think it's time for asteroid waves. Let's review stories. We create some questionable code and question it. It confesses and tries to reform. What do you think?

Let's do safe entry. Should I put this thing up on GitHub? No one has asked for that.

We'll review and refine the list of things to do and pick something. Doubtless fun of some kind will ensue. Loving PyCharm's auto-run of the tests!

Just some random cleanup, unless I get an easy idea.

Today's story is to make the missiles damage asteroids. But I have a larger question. P.S. I am the Cat ...

Let's see if we can make this thing fire a missile.

Our fun with delegation, plus an early call to breakfast meant that yesterday I didn't get to collisions. Let's work on that today. [Ron makes a rookie mistake.]

It's time for more features and less playing with drawing. This leads me to think about common behavior in motion and collisions. Ron learns something about inheritance and delegation!

Let's do to the ship what we did to the asteroids. And some thoughts about the future.

My search for why the window is double-sized caused me to observe that I can't scale my objects to arbitrary sizes. I think part of the issue is coupling, so that's interesting.

I noticed a graphical anomaly and think I can fix it. And another that confuses me.

One more tweak on the SurfaceMaker, then lets see about using it to make more asteroids.

I'm still pecking away at improving the surface creation. I'm wondering if my caching object, tiny as it is, is more than I need. We'll see. I think I should take advantage of the limitations of the current situation.

I have an idea, or some fraction of an idea. Let's see what we can make of it. (As often happens, I don't go where I thought I would.)

Some advice for a better way sends me scurrying to read about list comprehensions.

We don't even have 200 lines of code yet. How can refactoring make any sense already?

I'm at a low energy point but maybe I can get an asteroid up.

My plan is to wrap the flight path, which I realized last night is 100x easier than I've been doing it. But I was reading about the Rect object ...

Let's just inch forward by making the Ship turn ... and inch forward. I think we basically know how to do this. (I do quite a bit of refactoring, an odd thing to do in a spike.)

I've learned two ways to make the ship transparent. One of them is a good way.

OK, let's fare off on our own here and see about drawing a ship. As I am new to Python, this will entail learning how to create a list or array or one of those things.

I've decided to work with Python a bit. I think I'll enjoy it as much as Kotlin, and I'll certainly enjoy being further away from Gradle.