The long wait is finally over: The Good Suite v0.5.0 is here. There's still a long way to go, but I do believe that this is a large step forward in the evolution of The Good Suite.

This was previously meant to be the last release before splitting up The Good Suite in more separate modules, but I decided not to wait until I was ready for that Big Split and just release all the goodness that was cooked up over the years.

The addition of Collections to datatypes is perhaps the biggest highlight of this release. This was something that I was working my way around regularly by setting up datatypes that worked in what was basically relational way. No longer.

However, the major overhaul of the Condition system is also a good contender for that spot. It was less of an active bother before I started working on it, but it is completely revolutionary and as I have been using the changed version in some personal projects, it feels almost entirely unbearable to go back to an older version that still has the old Condition system.

Composer support is an improvement that's a lot smaller, but it's the thing that will make it happen that I will update those older projects to the current Good Suite version. Sure, there will still be a lot of changes to make because APIs changed in back-wards incompatible ways, but actually just having a version to refer to and that can be installed using modern tooling will absolutely be a gamechanger.

SQLite support was added what feels like a lifetime ago, but it was after the previous release and it's pretty essential as well. JIT-compiling is just one of those things that will make using the suite more frictionless. Pagination and boolean support in datatypes are very recent additions, but they are also things I have had to work around in the past.

And honestly, those are just the highlights. For a more comprehensive list, you can check out the downloads page.

Well, there's no stolen goods, and they won't be sold. Still, there's going to be some serious chopping it up into different parts, which are going to continue their lives under different names.

Once again, there have been years between updates. However, this time there have been a bunch of code changes since the last update. I have been using the library a lot myself and this has been pushing the development forward.

But as time passes, sometimes you need to correct your course. Last time, I announced the plan to separate the project into modules. That's not something that I'm changing, because it's simply the right way to go. What I am changing is when I'll do it. The original plan was for v0.5 to be the last monolithic version, but I have now decided that there will at least be a v0.6 before that happens. I do think that will be the last monolithic version, but perhaps it's better not to be too resolute this time.

Basically, I want to release my changes, even though I'm not ready for the big split yet. So, you could say that v0.5 is the extra release, or you could say that the split is delayed. Over the past few years, I have made a number of really big changes and those deserve to be released. On top of that, I am planning a few more things to be added.

Over the whole, v0.5 is going to be a pretty big releaase with a lot of improvements. I'd say there is plenty to be excited about and that this version will be vastly superior to v0.4. And this way, it'll actually arrive soon.

Well, there's no stolen goods, and they won't be sold. Still, there's going to be some serious chopping it up into different parts, which are going to continue their lives under different names.

It's been almost five years since the last release. There have been a few additions since then, but those aren't recent either. The logical conclusion, then, would be that this project is dead and forgotten.

That's not actually the case, though. I do still use this project from time to time, and each time I think about the improvements that should be made. I just never get to actually implementing them. That's about to change, though. The Good Suite is going to have to go through the biggest changes since its adoption of SemVer. (I was going to say "inception", but its rocky history would make that quite questionable.)

The Good Suite has always prided itself in not being monolithic. That is, you can use one or two parts without needing to use the rest. In a way, it's a collection of libraries, which adapts to your program structure rather than a framework, which prescribes a program structure. There is only one thing that you can install. That should change. That's why I'm cutting it up in different libraries, each with their own repository and version.

In the last paragraph, I used the word "install". The thing with that is that the way to use The Good Suite is to copy the entire source into your project. That's not good, and definitely not maintainable if there are separate packages. So, that's another problem that I'm going to attack here: each library will be installable using composer.

Then, there's something that has been bothering me a lot since I started using The Good Suite every once in a while: the naming. There are four packages that make up the storage part of Good, and even I have trouble remembering which is which. If I have trouble with that, what chance does someone that didn't write it stand? That's why the new modules will have less silly names, but instead just ones that describe what they do.

When we're changing the names anyway, there's something else that would also like to slip in. This relates to how I sometimes wish that the Good Suite also existed in different programming languages. One day, I might actually port it, but that day hasn't come quite yet. However, I will be including the language in the module names, so they can easily be distinguished from their ported counterparts.

There's a lot to be done. The first thing is to release v0.5. The current master branch does have some unreleased changes, which can't be the case when I do this. And while I'm at this, I'll try to make some other small improvements before making that release. But v0.5 will be the last monolithic release of Good. The packages split off of this monolithic repository will start at version 0.6 (which will be functionally identical to v0.5). In the future, any new libraries can start at 0.1. I definitely plan to scavenge some generic parts of other projects to get this honor...

It's here: The Good Suite v0.4.0. We're still on o.x.y and as SemVer dictates, this means everything and anything is still subject to change. There's still no documentation, but it definitely feels like the software is inching towards usability. The APIs have no more planned changes and seem to be mostly stable.

This release focussed on the datatype file format, which underwent some major changes. It looks better now though, and is more powerful as well. The full details and downloads can be found on the download page.

The future of The Good Suite seems to be full of possibilities. The next release will focus on making the functionality that's already there more usable and available. It is also scheduled to finally include that elusive documentation...

It's common practice that if you make something you can make a website or a part of a website with, the tool's website is made with that tool itself. After all, if the creator of the tool doesn't use it, how can he or she advocate other to use it?

The Good Suite has long escaped this practice. Of course, I'm not yet advocating for people to use it, so it's sort of okey. However, it was still something that I was aiming for. With version 0.3 of the Good Suite, the Good Looking API has become more or less stable and server side includes have been added - which was the main feature required to eliminate much of the duplication that was present in the static html version of this website. As such, this website was moved over to using Good Looking.

In fact, the move happened shortly after version 0.3 was released and most people will probably have noticed it. The only change to humans is that the file extensions have changed from .html to .php (it's better practice not to have either, but I'll leave that for some point in the future). The fact that I haven't found the time to write this until now is actually rather\ ironic, considering that this update made it much easier for me to add new news items to this website.

Of course, this website ought to use the entire Good Suite eventually, but that will be left for when the different APIs get more stable. For now, this is just a big step forward and it should be considered as such.

Today, version 0.3.0 is released. It's still no cakewalk to use it and as a SemVer 0.something version, everything is stil subject to change. However, though documentation is still lacking, the public APIs are moving towards stabilty at a high speed.

The main feature of this version is the addition of function -- and in particular include -- to GoodLooking. This is something that had been in the planning for a long time now and it was in fact a hurdle towards adoption even by myself. After all, what's the added value of a system like this if you can't include files? Previously, even I was better off using either static html or full php. No longer, as this functionality has now arrived.

On the the download page you can find the download and read the exact changelog.

While it's still unsure when I'll be abkle to find how much time to work on this, there is now a general roadmap, that describes which features will be in which version. The upcoming version is basically set in stone, while the last version may still change a lot. That said, this is what is planned at this moment.

Version 0.3 will be a small release, adding only a couple of features. Two fo these features will be the addition of variable assignment to the Good Looking templating language and a major stabilization of the Good Service generated classes through having both properties and getters/setters and having protected fields actually be protected. The third and last change is that we're finally adding functions to the Good Looking templating language. The lack of functions has been a major roadblock for adoption even by me for things like this website, as being able to include another file is at the core of any server-side processing. Now, this will be possible and I would expect this website to actually start using GoodLooking.

The version after that, version 0.4, will focus on changing the datatype file format. A number of changes to this fyle format are planned, including at least one that will break backwards compatibility. Getting this out of the way brings us a lot closer to a stable API.

The last version that is planned is version 0.5. The idea is that it will not focus on adding new things, but instead focus on making the current things usable. This means that documentation should be written, it should be possible to use the different modules without needing a couple dozen lines of code just to make sure that everything starts up correctly and that should become painless to install The Good Suite.

Finally, the second version of this software has been released. It's still rather hard to use, has no documentation and features unstable APIs, but that's why it's an "0." version (we're using SemVer after all). It can be found on the the download page.

In fact, there have not been any changes to this code for a while now. Having periods without any work on this project is not a new thing, but not releasing a version at the moment it was done is. The reason for this situation is that there was another planned feature, which was open for a long time, until finally it was decided to solve the underlying problem in a different way, and that feature was scrapped. This meant that all features for v0.2 were now done and it could be released.

Today, the very first version of The Good Suite is launched. It is called version 0.1.0 and it can be found here (there's a direct download as well as a link to the tag on github.

In accordance with the rules of Semantic Versioning this is a pre-release version with an unstable public API. This is very much the case still, and is the reason why I can't really recommend anyone to use The Good Suite just yet. On top of that, there are no documents detailing usage or the public API yet, so for both the only resource at the moment is the tests (which are not in the direct download, but can be found on github.

I recently found out about a thing called Semantic Versioning or semver. It's a description of when and how a version number should be incremented and can be found at semver.org.

I wasn't previously aware of such a system and had been thinking about writing my own set of rules. However, while reinventing the wheel is sort of a hobby on mine, I decided to pass on this one and use semver instead. This will mean people have a better idea of what the version numbers mean and assures good interoperation with things like composer.

Since no version has been released yet, the practical consequences are few. However, the fact that Semantic Versioning has clear rules about how you can alays break backwards compatility as long as you're working on version 0.x.y does stimulate actually releasing early on with zero point something versioning. Originally, the plan was to release a first version when the API was nearing stability at the earliest. Now, though, this plan has changed to one where we start handing out version numbers much sooner and one should expect version 0.1.0 to be released in the near future.

Version 0.1 will be released as a single bundling of the entrie Good Suite. This does not mean that this will be the form in which all future releases will be. How they will be done has simply not been decided upon yet. The liberty semver gives me before reaching version 1.0.0, though, includes not letting that stop me from releasing early and just stating that it may change.

The website you are looking at is up running.