The other day I asked for an analysis or at least an UML diagram since we are having quite some troubles and my boss looked disgusted at me for asking such a question. I’m not a professional backend developer, so I don’t know how it works professionally
I think there’s context missing from that story. Diagrams do not trigger disgust. At best, making superfluous and time-wasting demands in the context of trivial tasks that add nothing of value and achieve nothing but wasting time and adding overhead can often lead managers to frown upon them.
The DB is already made, but they had to change it cause they didn’t plan a huge portion of its logic beforehand even though they knew about it: this resulted in major changes across the whole schema
Blobs of json are your friend.
Seems kinda weird to me. It’s completely legit to ask for documentation before making it yourself. Some people are just more visual and need to see diagrams - they certainly help me.
That being said, I haven’t used formal UML in twenty five of professional development. I mostly use class diagrams and flow diagrams. Could be he was reacting to something that he feels is more academic and less practical.
The DB is already made, but they had to change it cause they didn’t plan a huge portion of its logic beforehand even though they knew about it. This resulted in major changes across the whole schema, while we were already working on implementing the various features
I see. So it’s an absolute cluster fuck because no one did the correct planning in the first place and everyone is flying by the seat of their pants. I don’t have a lot of information to go on, but this seems like poor leadership. And you know that because they had the requirements but didn’t create the right schema in the first place.
This (whether by leadership failure or honest mistake) is sometimes a reality in software development. And it sucks because that usually puts a lot of pressure on developers to hit moving targets because the deadlines don’t usually change just because you spent weeks working on bad design.
This is such a broad question. It’s normal and not normal to do so, it’s also normal not to do so.
If it turns out / becomes evident you need a diagram now now’s the time to create one. You may push quality even without seeing the value in it. In some places or with some people it may be unwanted.
I’m not the one who designed the DB; it’s not a simple DB or project though. The problem is, they “”“found out”“” they had forgotten to implement a very important part and they had to heavily change some parts we had already built upon
As others said, in-depth design is often skipped, especially if the dev team started very small. Sounds like your intuition is right, though - the lack of design bit them on the ass when they realized they missed a part.
I have also been laughed at when I suggested a UML diagram in the past. However, it is helpful. For more visually oriented people even more so.
I’d suggest to go ahead and do it, unless your boss is adamant that it is a waste of time. When they see the result they might be happy.
EDIT: writing it out, I swear, makes no sense at all
Oh I’m not the one who designed the DB, I just implement the endpoints and stuff for this particular project (my role is that of a FE dev).
I asked cause:
- they were saying that between me and my coworker, who actively work on the project, and the DB designer, the communication is poor. Which is obviously true since we were handed out the DB with an oral, confused, explanation for a complex DB so we have to ask a lot of questions or ask for very small fixes (sometimes a column is missing etc, nothing that important though);
- they didn’t foresee how interconnected the part 1 and part 2 were. Let me explain how stupid this is: the data from part 1 are mostly read only, which are provided from part2. We knew about this from day one, but it was never added to the visual design [which to this day is still in the making, so it’s incomplete]… and neither to the DB.
- when they actually went to work on part 2 - months later we had the green light to work on the project - they had this sudden realisation: the data are interconnected, we have to rework part 1! (which would have been completely avoidable)
I understand the predicament you are in, but I don’t know that you’ll get very far with your current approach.
The actual artifact you need from your collaboration is the list of API endpoints and the structure of what the request and response payload will look like for each one. This doesn’t need to be UML, it can literally be a text doc.
By asking for something highly structured that the other people may not know how to make, or do not have the tools to make, you’re putting them in a position where they have to acknowledge that they don’t know how to do something, or causing them to do work that they don’t value. Once you’ve had success on a team and developed trust/respect, you can push for adding process/tooling, but if you’re new to a team, you really have to work with what you’ve got.
Either of you could write a simple doc outlining the API and then collaborate on that (it’s also much easier to actually comment/collaborate on than a diagram, anyway).
I think you misunderstood, I’m the one implementing the API and writing the queries - alongside a coworker that doesn’t have BE experience. I’m not the one who made the DB though, neither is he, and the design is not very reliable
You said you were in the role of the “front end dev”. I presumed a structure of an API (usually implemented by a “backend dev”), and a UI (usually implemented by a “front end dev”).
My advice still stands:
You need to clarify the interface where each of your responsibilities are handed off.
If you are implementing the API, you can still produce the same document and then you need to get the other people that need to use it to verify that they can build what they’re doing from that. This means they will need to map the data from the API into the UI elements they need to provide. It also means that someone will need to see how that data will be sourced from the database, and identify anything that is not available in the database.
I’ve found most places aren’t very good at explaining the system design. Just make one yourself from what you understand, that’ll help you figure out how the system works, and your team will usually correct anything you got wrong (assuming it’s small enough to quickly review and notice incorrect assumptions).
I haven’t made a UML diagram in years. Or an ER diagram, for that matter.
Getting a schema dump and/or generating a diagram from an existing system would be useful, it won’t be UML, but can convey similar information. At a certain point, keeping an updated UML diagram is extra work that is almost guaranteed to go out of data instantly.
Yeah but knowing why something was made in that way would greatly help. The problem here is, the design is unreliable (just today we found an error in the design which changed an INSERT to a simple SELECT) so if we knew why certain things were made that way it would make our job much easier (in the end we have to ask if something weird was meant that way or it’s a design error)
I have no idea what you mean when you say you found an error in the design that says it was an INSERT instead of a SELECT.
If you are relying on a design doc with SQL in it, that’s a massive waste of time.
How many tables are in the schema? Have you reviewed them? Are there any naming conventions being followed, or is everything inconsistently named? Are there specific cases where tables are not normalized properly that you can ask specific questions about why they are that way? If the person that designed the schema is making “trivial” mistakes, there’s no reason to expect that stuff that doesn’t make sense to you will be something they intentionally did.
I guess what I’m saying is, you need to do some due diligence and survey the schema and write down some specific questions and that may lead to writing a UML or other doc to identify errors, but it doesn’t sound like you’ve done that.
Once again, it’s the norm, but it’s very bad. You should have at least some kind of “design specification” to explain what has been chosen. You can use PlantUML or Mermaid, and write this in some kind of spec. It’s not professional to skip the explanation, but most developers/managers do this.
Recently discovered d2 which has a somewhat nicer syntax.
While I‘m not a „professional“ in the sense of ever working for a classical software company and had to look up uml, I have been CEO before and most bosses are not very intelligent (but kinda smart).
He might have reacted that way because he either didn’t know what you mean or he wanted you to do the work of designing the database. Just a thought though.
The DB is already made, but they had to change it cause they didn’t plan a huge portion of its logic beforehand even though they knew about it: this resulted in major changes across the whole schema
I find that code written towards fulfilling some specific database design is usually a nightmare about 20minutes into the project. You end up with garbage semantics and interfaces because you’re building an entire app for the sake of storing stuff in a database. It’s an ass backwards approach to software development imo, software is about solving a human problem and data persistence is just one of the steps in the solution. Instead figure out what data your consumers need, then figure out what domain objects can be extracted from that, then plan how you will persist those domain objects. You’ll end up with less boilerplate, better naming of entities and services and you’ll also find that the words your team uses to talk to each other make sense to your business people not just your dba.
