Be bold and make changes. Document what you find out, what is outdated, what is missing.

Take ownership. If there’s nobody that oversees overall structure, be the one to do so - at least where you’re touching it or are being bothered by it.

Diatraxis gives some great insight and considerations input into writing and structuring documentation. Namely how different target audiences and doc use cases require different forms and detail levels of guidance.

My company’s internal doc/guidance also links to https://www.writethedocs.org/guide/ which seems like a good source.

Bare minimum place to start: See if you can get the team to agree that these documents should exist in every project root folder:

• README.md - What is this even for? Audience: Managers.
• CONTRIBUTING.md - What steps are needed to build this? What steps are needed to be able to run the tests? Audience: Developers.
• CHANGELOG.txt - Describes the contents of every tagged release. Audience: end users.

Stretch goal: pick a spot (readme is fine) and make a list of sources (data in) and sinks (data out). Include contact information for whoever can reset the credentials or fix the firewall.

I would say as a new junior dev you are uniquely placed to help with this. Documentation tends to be written by people who know a lot about a thing and they try to imagine what might be useful for someone. Someone new coming in with a fresh perspective can help uncover assumed knowledge or missing leaps to make the documentation better. One of the common onboarding steps I’ve seen is to go back and update/improve the onboarding docs after you’ve just been onboarded for example.

I would say pick your battles though because documentation can be a never ending task and documents are almost always out of date shortly after they are written. Think about what would have saved you time or mental overhead if it was just written down and fix those first.

As far as organising and writing, every place is different and it can depend on the tools your org is using. In general I’d at least have links to relevant docs as close to where they might be needed as possible. Like how to set up and get up and running with a code base should probably be documented directly in the readme, or at least linked to if it’s overly complicated.

Hopefully that’s at least somewhat helpful. It’s definitely a problem basically everywhere I have worked though, you have to do what you can and not stress too much about it.

The Code is my Bible.

Things I encounter include incomplete documentation, outdated documentation and written process details that have assumed knowledge which makes it difficult for junior Devs to pick up.

Yeah seems about right… off the top of my head:

• self-host a wiki, use it to document stuff
• write clean code that your future self will have an easy time reading
• avoid automated documenting tools

Others may find this sacrilege but this is one the best uses for ai at the moment. I toss it methods and ask it to describe what’s happening each method. Then after you’ve gone through a whole class ask it to describe the whole class. If you break it up well it can very quickly document massive code sets specifically for both technical and non technical people. Even better it can take that same documentation and convert it to highly detailed and advanced markdowns for wikis. This will also help you review your code. If the ai is having an issues understanding what you’re doing you can bet anyone else dropping into it without backup is going to have issues too. Particularly PO’s, QA, Scrum masters and all those they meet with when you’re not there. It has saved me repeatedly showing up in meetings where those other non technicals just “ho hum” their way through meeting questions, come back asking where docs are because they usually don’t even bother looking. “No one else had anything documented and we didn’t see it so we just wondered.” “Yep here it is, here’s it broken down by class, here’s the method, here’s the variable types in and out, and here’s the quick overview levels 1,2,3,4 and 5.” All getting progressively more technical. My PO has thanked me repeatedly for saving her ass in meetings where they complain about lack of documentation but not from me.

Partial documentation combined with complex code will be great for your bank account.

Code fast, and badly, always under promise and over deliver. Before the shit hits the fan, move to another place.

Next person after you will take the blame. You may be hired again at premium as you can deliver. Blame the replacement Dev for breaking the code and causing a lot of damage.

Fix the little that is possible, at premium rate and move on.

Keep it all together with the code and use f.e. asciidoctor or rst ( python ). There is also doxygen but it’s not most user friendly

This is the sort of thing you have to learn by experience, like how you can’t really learn good coding taste from reading a list of rules (though some lists are helpful).

Anyway in my experience documentation is quite different in public (i.e. seen by customers) and private (inside your company). For internal stuff there’s a much smaller incentive to document things because:

1. documentation tends to be inconsistent (as you discovered), so people give up looking for it. Instead they just ask other people. This actually works fairly well inside a company because you can generally easily access whoever is responsible (as long as they haven’t left).
2. there aren’t customers to keep happy and away from support.

I think the best thing to do is to accept that people aren’t going to expect documentation internally. There’s zero point writing guides to tools on your company wiki or whatever, because nobody will even try to look for it - they’ll assume it doesn’t exist.

Instead you should try to keep your documentation as close to the user as possible. That means, don’t have a separate docs folder in your repo - put your docs as comments in the code.

Don’t put deployment instructions on your wiki - add a ./deploy.sh script. It can just echo the instructions initially.

Does anyone have any good sources or suggestions on how I could look to try and begin to improve documentation within my team?

Documentation in software projecte, more often than not, is a huge waste of time and resources.

If you expect your docs to go too much into detail, they will quickly become obsolete and dissociated from the actual project. You will need to waste a lot of work keeping them in sync with the project, with little to no benefit at all.

If you expect your docs to stick with high-level descriptions and overviews, they quickly lose relevance and become useless after you onboard to a project.

If you expect your docs to document usecases, you’re doing it wrong. That’s the job of automated test suites.

The hard truth is that the only people who think they benefit from documentation are junior devs just starting out their career. Their need for docs is a proxy for the challenges they face reading the source code and understanding how the technology is being used and how things work and are expected to work. Once they go through onboarding, documentation quickly vanishes from their concerns.

Nowadays software is self-documenting with combination of three tools: the software projects themselves, version control systems, and ticketing systems. A PR shows you what code changes were involved in implementing a feature/fixing a bug, the commit logs touching some component tells you how that component can and does change, and ticketing shows you the motivation and the context for some changes. Automated test suites track the conditions the software must meet and which the development team feels must be ensured in order for the software to work. The higher you are in the testing pyramid, the closer you are to document usecases.

If you care about improving your team’s ability to document their work, you focus on ticketing, commit etiquette, automated tests, and writing clean code.

Leave before it matters

Code should be self-documenting. That way it is never outdated. Here’s an example of this similar to what you can expect to see in practice:

def nabla_descent(X, y, theta, alpha, delta, nabla):
    m = len(y)
    for _ in range(delta):
        h = X.dot(theta)
        nabla = (1/m) * X.T.dot(h - y)
        theta = theta - alpha * nabla
    return theta