That makes sense, as these products are still under active development. Based on the customer feedback seen here, it's likely to require a similar sustained level of effort for quite a while, just to polish the features that are expected right now. Every new feature and every newly released product will require additional effort.
I'm basing my assessment on more than three decades of experience developing software, firmware, protocols and APIs and teaching this stuff at the tertiary level. I've seen many different approaches and results ranging from unmitigated failures, through acceptable solutions and even some great success stories. There's no guaranteed recipe for success, but there are certainly some approaches that tend to have higher success rates than others. One of the things I've seen repeatedly is that APIs that are published early and in a forum that encourages vigorous discussion, tend to lead to better final designs. Critical review is vital when it comes to discovering blind spots or "thinkos". In some cases these reviews can encourage redesigns before too much effort is invested heading down the wrong path. Developing consistent, orthogonal APIs with a small footprint is best done when you consider the widest possible scenario of use cases and distil all the requirements to the core basics. When you continue developing an API internally until you consider it final and ready for public release, you run a very real risk that someone will find unexpected weaknesses in the API after you have committed to it. Once that happens, you have very little room to move. You either break compatibility or start cluttering the API with workarounds. On the other hand, when you develop the API in the open you do so with the understanding that the API is evolving, that there will be changes and that developers are active enough to both provide feedback on your changes and keep their own code up to date. At some point during that consultative process you discover that certain parts of the development API are stable enough to officially bless them as a stable release. Because those stable parts of the API have seen (hopefully rigorous) review and have been tested by multiple consumers under differing circumstances, it's very likely that the design is going to be at least adequate.
As to why I don't think you'll be able to satisfy
all the feature requests coming from the user base? Very simply, it's not cost effective. There will be people out there that will want something that is esoteric, not considered a core feature and will likely cost a fair bit to develop. As you say, you are "evaluating" the requests, which certainly means a cost/benefit analysis. If the return on investment for a feature is not obvious, it will simply not get done or it will be put on the back burner. There are people, such as myself, who may be willing to sink in a major amount of effort into developing something that "scratches their own itch". The initial commitment to start on that development path usually happens on the spur of the moment. If the initial hurdle to getting involved is too big, nothing ever happens. As a rule of thumb, if a potential developer can't get started in one day/evening, they are very unlikely to become engaged. That typically means having all the documentation and a few working examples ready to download from a publicly accessible location. Any hurdles you put up, such as requiring license or non-disclosure agreements, applying for special keys or accounts or requiring developer reviews and approvals will result in attrition. Put up enough of these barriers and there will be minimal to no uptake.
See above. You would benefit from early feedback during development so that you can eventually stabilise a good API. There's no need to get the API to the final version behind closed doors. Most developers will understand that an API in development is subject to change and that it is their responsibility to keep up with the changes. It is however important to spend a bit of effort on documenting the changes and the rationale behind making them. This is a good thing as it requires in-depth thinking and justification for changes. Doing so leads to better designs, better documentation and higher quality code.
It's great to hear that the roadmap includes a public API. This will no doubt allow others to add value to the RAPT eco-system. Do consider opening up developer access earlier, perhaps as an open beta, so that you can benefit from external input. No matter how much you pay your developers and how good they are, there will be someone out there that will have an idea that they didn't even consider. Of course, there will also be some tyre kickers, but that's OK. Sometimes they ask interesting question that get the core developers thinking along new lines.
I'd like to see a feature for controlled natural carbonation in pressure fermenters. In particular, the ability to close a valve once the SG reaches a preset (say within 10% of expected FG) and then have the pressure / temperature regulated to reach a desired level of carbonation. Say, I wanted to get my IIPA to finish at 2.3 volumes CO2, fermenting at 18C, once it reaches 1.022, I want to start building up pressure, take it to 20C for a day or two to clean up, down to 16C over 8 hours, then wait to reach expected FG. Once at FG, hold at 6C and 2.3 CO2 volumes until I'm ready to transfer to serving keg. I'd like the means to monitor the fermenter pressure during this process and to open and close a CO2 pressure valve as required to maintain the desired head pressure at different temperatures. Ideally the algorithm would take into account that there is a considerable amount of time required to re-absorb CO2 into the beer when temperature drops. A simple lookup of temperature vs equilibrium pressure is not sufficient.
Anyway, long post. It would have been better to chat in person over a few pints...
Next time someone from KegLand is in Sydney, please come and chat to brewers from
Flat Rock Brew Club over a bunch of beers.