▲ 275 points
back
71 comments
I think (a good) changelog is especially important when it comes to closed-source software where you don’t have the opportunity to downgrade easily (from Windows software to mobile applications).
For example if you visit the App Store now, you’ll see the many app developers, especially the big ones such as Twitter, Facebook etc., are using the same changelog entry for every, single, update: “Thanks for using X! To make our app better for you, we bring updates to the App Store regularly.” The problem is, this doesn’t tell me anything about what to expect. No, I see that I shouldn’t have anything to worry about because the new features are throughly UX-tested, and as an app end user there is not much to consider anyway (it’s not a framework I’m using in production, right?).
The problem is, the changelog matters when Facebook removes messaging functionality to push its users to their new app for some for-profit reason. Changelog matters when your favourite app which has been free for the past couple years have decided that it’s monetisable now and there are intermittent ads in your feed. It matters when they think you don’t need a functionality anymore and proceed to remove it, but you actually do.
I think changelog should be enforced far, far more strictly for closed-source software, and especially for those on App Store and Play Store.
Couldn't agree more. It's been heartbreaking to see the spread of those rote changelog entries on iOS specifically.
Although, meanwhile, large companies like Apple and Google have started including surprisingly high-level and compelling release notes or changelogs to end-users in things like Chrome and Keynote.
Smaller shops like Transit, Halide, Darkroom, and many others are going the opposite direction of Twitter and Facebook by offering very detailed and compelling (although sometimes a little too over the top) changelogs for their major releases.
One thing I wish people did more, and I feel like I should carve out a section about this on Keep a Changelog: explain exactly what bugs were fixed. I know discrete updaters are becoming more rare with auto-updates, but seeing a specific bug that affected you specifically squashed in a release is perhaps one of the greatest values of changelogs, especially in the case of open source software but also with closed source apps.
> on iOS specifically
I wish. It's rampant on Android, too; of my recently updated apps right now, about half of them have release notes on the order of "bug fixes and performance enhancements". Even Google does it on their big-name apps!
If you care that much about a specific bug, why not file or follow the relevant issue ?
It shows maintainers which are the real issues affecting people, allows two-way communication about the bug, and keeps the changelog clean.
Nodejs is an example of a project that seems to mention every single fixed bug in their changelog, making them so long that I'll probably miss the things that really matter while skimming over them - especially when jumping ahead a few versions.
There’s reason to hope this might get better on the App Store: part of the app review guidelines updates this year addressed this specific issue. From http://www.appstorereviewguidelineshistory.com/articles/2018...:
> Apps now must clearly describe new features and changes in the “What’s New” section of the App Store. Several of the large social network companies have been using a practice where they reuse a generic update text for every release and then enable new features remotely on a per-user basis. This appears to no longer be permitted.
It's so annoying to see:
"Every update of our Facebook app
includes improvements for speed
and reliability."
One of the reasons these big ones don’t use a proper changelog is because new, and deprecated, features are controlled by dynamic feature toggles as opposed to what version of the app you are running. Of course, new version adds support for new toggles (features) but that is not a guarantee that they will be enabled for your user - or at all.
> Changelog matters when your favourite app which has been free for the past couple years have decided that it’s monetisable now and there are intermittent ads in your feed.
That's a pretty uncharitable interpretation. After all, you used your favorite app for free for a couple years. Maybe they ran out of money. Maybe they tried to monetize in another way, but it didn't work and ads were the fallback to keep the service afloat (though also possible ads were the plan all along once scale was achieved). In any case, your favorite app isn't free to develop or host and you're not under any obligation to use it.
I generally ignore those updates. If you can't take the time to sell me on it, the current version is fine.
Flash degrades on writes. There's not that much space on a phone so why spend writes on weekly updates with no visible benefit.
The problem is, the changelog matters when Facebook removes messaging functionality to push its users to their new app for some for-profit reason.
App makers thought that monolithic multipurpose apps didn’t work well.
Google did the same thing.
https://www.computerworld.com/article/2488851/mobile-wireles...
Since, as okket mentioned, Keep a Changelog has been featured on HN before let me give you... a changelog of what's happened in the project since the last time: https://github.com/olivierlacan/keep-a-changelog/blob/master...
Version 1.0 was released introducing: a much cleaner website presenting the guidelines in a more digestible way; 13 new translations; a semi-decent versioning system to help synchronize translations; and a lot of clarifications and updates based on feedback and conversations that occur regularly within the project issues: https://github.com/olivierlacan/keep-a-changelog/issues.
I know trying to get ahead of the torrent of critical comments is pointless but let me summarize: yes, I know you think changelogs have been defined before. But you know just as much as I do that most changelogs (or whatever you decide to call them in protest) are terrible and not as helpful to software end-users as they should be.
There's been a lot of progress in the past 3 years alone in that regard. It's nearly unthinkable for an open source project to not include a decent changelog for each release. That's good. There are still a lot of smaller, less known, or older projects that could be improved with some basic changelog hygiene. If you're interesting in helping, please do, and if keepchangelog.com can help I'll be glad.
Here's hoping this becomes mainstream again.
The usual "Make sure to grab the latest update to get the greatest experience. We bring you performance improvements and bug fixes every 14 days" or some annoying joke about dusting code off, taking the trash out and fixing the space-time continuum is getting pretty tired.
The most infuriating changelog lines are the ones that just say 'bug fixes' or 'enhancements' (or 'improvements'). Too many change logs have these lines.
I have written exactly that kind of changelog. Let me explain why.
I write the changelog for a product. In fact I write two changelogs - one for engineers and one for customers.
Engineers:
- [New Feature] Added ability to ___
- Improved logging on ___
- Fixed a memory leak on ___
Users:
- [New Feature] Added ability to ___
Not every change can be explained in one sentence to users. Internal logging? Memory leaks? You're speaking a foreign language. Those entries must be thrown out when making the changelog for users.
Eventually, there comes a release when you have thrown everything out. What do you write? "Bug fixes & enhancements".
It's a bit annoying to document every single bugfix in a changelog too, though. At least I don't want to read dozens of lines like
- Fixed flickering lower-right pixel when hovering over close button with a stylus on devices with more than 300 % UI scaling applied.
- Fixed alignment issue in About dialog.
- Improved help text for Gizmo frobbing feature.
To me a changelog should prominently document changes in function and behaviour. I don't particularly care if an exception message got a typo fixed, but I do care about a new feature, if a login problem for a subset of users has been resolved or a crash under weird circumstances has been fixed.
True, that doesn't really give much more info than "updated" does.
Previous discussions:
https://news.ycombinator.com/item?id=12370119 (45 comments, 3 years ago)
https://news.ycombinator.com/item?id=9054627 (43 comments, 4 years ago)
See also issues/pull requests in the repo:
As far as I can tell, the autogeneration of changelogs you can do with standard-version https://github.com/conventional-changelog/standard-version and commitzen ( https://github.com/commitizen/cz-cli ) fulfills the criteria Keep a Changelog wants: right date format, clear notes for breaking changes, and no unnecessary information from irrelevant commits. I've really liked using the two for a variety of systems - the strict commit message formatting and opinionated changelog generation means that the resulting changelogs are pretty darn readable. But ymmv.
Seconding this recommendation. Recently began using them at work and it's improved engineering <--> company communication, as well as engineering <--> engineering communication since I can look at the generated changelog and know exactly what changed there, in ALL commits.
These are node-specific tools. Do you know of anything similar but generic?
Ideally, one would have something that can be connected to project-management tools rather than github, e.g. Trello: when you mark a checklist or archive a card, the title should go in changelog.
He says not to use your repository commit messages as the source for your changelog text.
That's exactly what I do use.
I started doing this after reading "The Pragmatic Programmer" where it's argued that the DRY principle should apply to everything including documentation.
It starts with the bug tracker. So when entering something in that I'll also add the text that I want to appear in the changelog for the user to see (these lines will have a // at the start).
When a bug/feature is completed a commit is made and the text in the bug tracker is the commit comment. If the commit comment has a line starting with a // then that line will have another line inserted above it //Bug fix: or // Feature:
Finally on building the distributable the changelog is constructed entirely from the lines in the commit messages that start with //
That's also what I do. When releasing a new version, I run a script/gradle task/... that:
- compiles all commit messages since previous version
- filters unwanted messages (according to special tags)
- groups them by category (fixes, enhancements, ...)
- opens an editor so that a human can prettify the changes
- appends the end result to changelog
- updates version files
- commit changes / git tag / etc
EDIT: formatting
BTW, I always have to set up those tasks myself. I'm surprised some kind of standard tool does not exist. I guess everybody has their own preferences and no standard really emerged...
There are probably a lot of tools that do this. The conventional-changelog[1] is one project, and it links out many others. AngularJS is a good example of a project that's been using that style for quite some time. I ended up using that as inspiration for my own tool (similar to yours) because as you mention, a lot of the pieces can be idiosyncratic to the project, and it turned out to be a relatively straight forward affair anyways. But if I were starting an open-source (node) project today, I'd probably just use the standard-version tools and forget about it.
[1]: https://github.com/conventional-changelog/conventional-chang...
I like your idea of opening it in an editor to prettify it up. It seems to go at least part way to integration Help Documentation in the process which is something I'd like to achieve
Open source projects are one things.
For customer projects it is somewhat rarer to have a decent changelog. Though, I think that Blizzard is awesome at it: http://us.battle.net/sc2/en/game/patch-notes/3-9-0
(see both new features, game mechanics balances and bug fixes).
I view the Changelog as a sales tool: It shows how much work you're doing on the project. I'm developing a cross-platform file manager and try to keep its Changelog very visual [1].
This isn't a changelog, this is a NEWS or release-notes file.
Keeping a changelog in version control is an invitation for artificial conflicts on every single commit. (There are ways around that, but better to not keep a traditional changelog, since version control does completely make those obsolete.)
But keeping a NEWS file is an excellent practice. And when you send out a release announcement, you can include the corresponding release notes for that release.
Yeah, that's the GNU coding standard. Changelog is for developers and bug hunters to see changes to the source. Version control probably takes the place of that now. NEWS is for "user-visible changes worth mentioning".
https://www.gnu.org/prep/standards/html_node/Documentation.h...
People generally use those independently now. The meaning of the english word is changing.
I wrote github-release-notes to help me stop being lazy about releases. It generates a log based on github PRs. It's not a perfect solution, but it's a place to start, and helps track down the work done and the comments made so I can start writing better notes. A lot of times, the first comment of a PR is a great source of information about a change made (what, why, caveats, etc).
I really like reading hand curated changelogs. In a weird way, sometimes reading a changelog can be more satisfying than using the new version.
Seeing this my first thought was "Oh cool, so you format your git commit messages in a certain way, and then this tool will automatically generate changelogs for you."
... but it wasn't that (rather, just good arguments and suggestions).
And now I'm wondering if my first thought is a thing? And if so, how it has worked out for users.
People have created million and a half tools to tackle this problem. Just look at the issues and you'll find a ton: https://github.com/olivierlacan/keep-a-changelog/issues?utf8...
I've tried to refrain from endorsing tools because I feel like they risk making it easy to avoid doing what I actually encourage: curating the notable changes for a release with your mushy human brain for other mushy human brains.
I know it's hard, but perhaps it's a good constraint.
The idea that you will have the forethought of knowing when writing a commit that it'll be one of the notable entries in your future changelog seems a bit far-fetched to me. And as I tried to explain, the purpose of a commit is not the same as the purpose of a changelog entry, so there's definitely tension in the re-use of copy there.
I get the instinct to automate everything. I'm just not sure this is something that should be automated. Now, an assistive tool to help maintainers review commits for missing notable changes within a changelog, that's something I could get behind.
> so you format your git commit messages in a certain way, and then this tool will automatically generate changelogs for you
https://github.com/aldrin/git-changelog https://asciinema.org/a/Jk8A5UEJGkhlalL4gl3HevC7e
Not quite a change log but something we've found useful with our clients is https://shippingreport.com
It uses PR messages to make a report of what changed.
If your PR messages are nice (we use animated gifs to demo changes) then you end up with some really nice reports.
That's sort of what I was talking about, but I was getting down-voted for not explaining myself. It seems redundant to keep a changelog with its own state when writing good, user-readable version-change commit messages is something you already do. Using git-rebase could help you work in a version-change specific commit meant for users.
To clarify, not all of your commits need to be user-readable, since the majority of them are meant for developers -- just the sparse ones that capture the version change need to be user-readable.
Then you'd have a full commit history for the nitty gritty details and a subset of your commits would be used to generate a pretty changelog.md for everyone who wants the TLDR.
I like to think MMOs can be idolised a little bit when it comes to changelogs.
Just check out these patch notes for Patch 4.0 of Final Fantasy XIV:
https://eu.finalfantasyxiv.com/lodestone/topics/detail/8937c...
Is your average player going to read all this? Probably not but it's still fascinating to see the amount of effort put in for every change, major or minor!
Keep a Changelog is a great resource! I actually built a service inspired by it. https://onset.io, check it out. :)
Not sure what the policy is on self-promotion but if you're using Rails, my company wrote https://github.com/CatchRelease/stenographer to keep our team up to date on changes. It works by detecting [changelog foo] in your commit message and detects deploys across environments.
This is great. I bookmarked this and will be referring to it consistently as I roll out my first serious open-source project. Thanks!
Writing release notes for a very active project is pretty hard and time consuming. I can understand why large companies simply say "Bug fixes and improvements" instead of "14 A/B tests that help us understand what to build"
I write release notes for Figma and it definitely takes a lot of time, is not perfect, and becoming increasingly challenging.
Orfox/Orbot on Android seem to have no changelog, anyone know who I could nudge and/or assist to make one happen?
Orfox issues link on f-droid is 404 I notice now.
I find it rewarding to clean up my commits, add the work done on the CHANGELOG.md and push the branch for a PR and move on.
Hacker News paydirt!
I love it when I find something that directly relates to every day productivity. Kudos to the provider.
Wouldn't proper use of `git rebase --interactive` make changelogs unnecessary?
No. The commit history is for the developer perspective, the changelog is for the user perspective.
As a user you don't want and need all the details what changed between two releases. As a developer you absolutely need to be able to look this information up.
Not everyone who might be interested in your changelog will be a developer. Even developers don't want to go trawling through commit history to know changes at a high level.