Hacker News new | past | comments | ask | show | jobs | submit login
Keep a Changelog (keepachangelog.com)
275 points by privong 7 months ago | hide | past | web | favorite | 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!

I found that the changelogs on Android have never been that high quality to begin with. This is probably because from a very early stage (version 3.3.11), the Android Market automatically updated 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.

> It shows maintainers which are the real issues affecting people

I disagree. Sure, it's a signal, but it's quite distorted.

Suppose you have an issue that affects a lot of people, but has a simple workaround. You may not see this issue since no one bothers to file a bug. If in doubt, I'd prefer to fix a papercut that affects 50% of my users vs. a catastrophic show-stopper bug that affects 0.01% of them.

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.

> and then enable new features remotely on a per-user basis

that should still be permitted, no?

they'll just have to write "we added feature x, which we'll slowly roll out to all eligible users."

> they'll just have to write "we added feature x, which we'll slowly roll out to all eligible users."

This would be vastly preferably to the current: "Bug fixes and performance improvements"...

It's so annoying to see:

    "Every update of our Facebook app
     includes improvements for speed 
     and reliability."
It gives the impression that they've lost track of what they're updating or they want to hide what they're changing in the updates... also just very lazy


Some phones have it as part of involuntary bloatware. The most you can do (short if rooting) is Force-stop it.

Is that real? Which phones are doing this to their consumers? That is fucking awful.

Yea sure, these are the two choices ONLY...

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.

Even if they're not enabled by a user, surely it's important to state when they are added/removed from the application.

I would like to check before I upgrade, if an app removes a feature, regardless of whether I'm using the feature or not.

It’s not the user who is enabling them. It’s the app developers. They can remotely toggle features on and off.

So some app configurations are changed by the developers at runtime.

That doesn't mean they have to hide the existence of those features, or the reason for the update.

> 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.


Correct but in Facebook’s case they were also trying to push Messenger as a messaging platform that you could use without Facebook too, hence a separate app made more sense on a technical level, but also it was a huge marketing move.

I personally find it annoying that Messenger is integrated into Facebook enough that I’m notified when there are pending messages, but not enough that I can’t check my messages on FB app...

Don't let facebook force you to install their messenger app. On https://mbasic.facebook.com you can still read the messages in the mobile browser.

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.

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.

> At least I don't want to read dozens of lines like

I must be a crazy user, because I generally like reading through changelogs to see if an update is worth applying because it addresses a specific issue I am having, implements a new interesting feature I want to try, or fixes critical flaws.

Luckily, though, public bug trackers are generally a good way to find out at least the 'is my bug fixed' part without the changelog (your issue is closed as 'fixed in X.Y')

Yes, it is possible to mention such. It is not important for most users, but super important to ones affected by a given bug. Vide:


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.


- [New Feature] Added ability to ___

- Improved logging on ___

- Fixed a memory leak on ___


- [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".

You could say something like "fixed stability in account management" or "fixed crash issues across application, improving stability across board". I sympathize with not wanting to go into more detail than would be generally understood by the audience, but there's a large chasm between "bug fixes" and that. If I was experiencing those bugs, I can now expect them to be fixed and I'm now in a better spot if I see them again to say "hey you didn't QUITE fix that in release X". If I see "bug fixes", I can't guess what happened in that release.

We already have our bug tracker for the engineers so why do twice the work? Most engineers don't care once the product is 'out' they only care what they're working on.

So we create our change log (they are part of our 'release notes' actually) with only the user in mind but we reference the bug tracker number next to it.

This is what we check in to the 'source' for the release notes.

Then when we post to the 'outside world' we just remove those tracker numbers (takes a few seconds).

That way the engineer can see the 'easy to understand conceptually' bug fix/enhancement and if they want to know more then they can see the Tracker reference and go and look up the 'real meat - with all the discussion and threads etc.

For those bug fixes that we 'don't' document we have our source code software.

We have 4 sections to every changlog release: New, Improved, Fixed, and Internal

We maintain a CURRENT_CHANGES.md with those sections. When we do a release, we move the contents of CURRENT_CHANGES to a new entry in RELEASE_NOTES.md.

One of these days, I will get around to writing something that displays RELEASE_NOTES in the app, without the Internal section

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.

I would like something generic as well. I used to use semantic-release[1] but it's a bit too Github-specific for my tastes.

[1]: https://github.com/relekang/python-semantic-release

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

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].

1: https://fman.io/changelog

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 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).

[1] https://github.com/buchanae/github-release-notes

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".


Many people and projects now use NEWS that don't have anything to do with that particular coding standard.

People generally use those independently now. The meaning of the english word is changing.

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.

I think the issue with automation is it requires a cultural change for most companies / projects. People are very used to small atomic commits and so it’s hard to reduce the noise once parsed into a changelog. To make it work, you need each commit to be as meaningful as a line in the changelog.

We use Phabricator and it’s default workflow, so have a clean linear git history. Phabricator already requires strict formatting for any new diff (title, description, testing, etc). It’s built into the culture of any org using Phab to consider commits as meaningful entries in the history of the project. So it would be very straightforward (technically and culturally) to require a simple title prefix ala Changelog (ADDED, FIXED, SECURITY, etc) for each commit and have yourself a automated and meaningful log.

> you need each commit to be as meaningful as a line in the changelog.

Not really, your changelog-from-git-log generator doesn't need to incorporate every single commit. The vast majority of commits shouldn't be incorporated in a changelog anyway, since fine-grained commits serve a different purpose. It could incorporate, for example, version-change commits whose messages serve the exact same purpose as changelog entries.

  git commit -m "VERSION 1.1.0 <user readable desc of changes since 1.0.0>"

> 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.

Keep a Changelog is a great resource! I actually built a service inspired by it. https://onset.io, check it out. :)

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:


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!

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.

I really like reading hand curated changelogs. In a weird way, sometimes reading a changelog can be more satisfying than using the new version.

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.

I've always thought of the term changelog as being the full list of every single change for the purposes of developers. Back before we had git and used CVS or patches it was necessary to track all changes and this was often in a file named ChangeLog. User relevant changes go in release notes or (a NEWS file if you follow GNU conventions).

Changelog is a bit ambiguous, indeed. Release notes would be a more fitting name, but also not ideal IMHO. If you want to know what was changed and when, you need the commit history anyway. Also for bisecting.

I'd argue these days changelog and release notes are more interchangeable than changelog and commit history. The 'NEWS' GNU-ism never really caught on, maybe because news does not imply log/history.

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.

Okay, fine -- but why couldn't you just derive a changelog from version-change commits which are meant for summarizing high-level changes in the version being committed? That way, you don't keep multiple sources of truth for version change information, while still benefiting from keeping a concise changelog without unnecessary commits in it.

Applications are open for YC Summer 2019

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact