It seems that way at first, doesn't it? What's actually happening is that you're being given feedback in an unintuitive way. When in supercruise, the yellow bar doesn't indicate speed, it indicates the proportion of safe maximum speed that you're travelling at. As you approach your target this safe speed decreases, and if you're travelling quickly it will decrease at a faster rate than your actual speed (even if you set your throttle to 0). The audio feedback is tied into this bar, so it also sounds like you're accelerating. The reason this 'bug' doesn't get fixed is that it's by design.The auto-throttle is broken badly. Here's a modern day analogy. You have a car with cruise control. You set it and head down the road. Ahead you see a traffic jam so you cut throttle and apply the brakes, but instead of slowing, your vehicle accelerates to maximum speed and smashes into the others.
As for bug fixes in general, you need to know a little about software development to understand why the frequency of bug fixes drops off over time. When you have multiple developers all working on the same code, you don't just all pile in and start hacking around. If you work like this, you end up in a complete mess. What actually happens is that Frontier will have one ongoing development stream (usually known as the trunk) and when they start on a bit of work, be it a bug fix or a new feature, a developer will take a snapshot of this development stream known as a branch. Any work they do on the branch has no immediate effect on the trunk. In this way, all developers will be working on their own copy of the code. When a piece of work has been done and tested on the branch, it will be merged to the trunk. You usually get some help from the tools here, but where two developers have touched the same code -- which happens more regularly than you might imagine -- you get what's known as a conflict, and one or both developers have to manually pick apart what each developer did and get it integrated correctly. There are ways to minimise this, but it's an important concept to understand.
So think of this thing like a tree. You have the trunk, which grows ever upward. Off this sprout branches at irregular intervals. Branches may have branches. Eventually the majority of those branches rejoin the trunk, somewhere nearer the top. So, what happens when we do a release? Simple, we take a branch of the trunk (call this a release branch) and this release branch is what we maintain and release with bugfixes.
When a bug is identified and fixed, the developer assigned to it has to work out the root cause, figure out where it came from and fix it. But where should they make that change? It definitely needs to go into trunk, otherwise it'll get forgotten about and future releases will still contain the bug. If you want to do a bugfix release, it also needs to go in the release branch. When the trunk and release branch are fairly near each other, this isn't usually too difficult. But as time goes on, the code can diverge significantly. It may not be possible to make the same fix in both branches. It may be that it's been fixed indirectly in the trunk through some other change, and in either case the developer needs to spend effort effectively implementing the same thing twice, possibly in two different ways. Whichever branch you do the work on, the number of conflicts that arise from the merge will increase over time. So as time goes on you get diminishing returns from bugfixing the release branch; it doesn't mean they've stopped fixing them though. Pushing 1.3 or 1.4 back by a month to get bugfixes implemented into the 1.2 release branch would be a waste of money.
The one thing that Frontier could do better would be to maintain a list of known bugs and their status (e.g. fixed in 1.3, planned for 1.4, etc.).
Last edited: