Training Preparation -- What 100 Attendees Dislike About Software Development

Least favorite thing about dev

Show
-
Show
- slow deployment/testing
Show
Agile
Show
Being told what and how to build something.
Show
Broken or difficult to use tooling, ever changing requirements, unrealistic schedules
Show
Bugs and unit-testing nested if statements...
Show
Business challenges that slow down or stop you from developing.
Show
Changing legacy code
Show
Chasing difficult to reproduce bugs.
Show
Clunky tools, anacronyms of C
Show
Commenting code
Show
Complex design which involves too much time to debug if its not self written.
Show
Complexity and quality of some legacy stuff
Show
Complexity, bloat, inconsistency, too much code that should never have been written.
Show
Computers, windows, technical debt, slow building/loading/feedback loops
Show
DEBUG
Show
Deadlines
Show
Deadlines set without a good estimation process
Show
Debugging can be difficult and time consuming and/or I write myself into an architectural corner.
Show
Documentation process
Show
Estimation
Show
Examine/Debugging others code
Show
Fighting with the initial setup of a testing toolchain
Show
Firmware can be frustrating because of non-intuitive SDKs, clunkiness of building, flashing/debug
Show
Frustrating problems that don't seem to have a good solution.
Show
Fully testing functionality to catch every edge case at the end of writing the code.
Show
Hacks, hardcoding, temporary throwable code etc.
Show
How much time is spent trying things until it works and how brittle it often is.
Show
I don't like full ownership of large projects by a single dev.
Show
In medical -- the long time it takes to develop a few lines of code.
Show
It can feel like a grind sometimes
Show
Libraries that contain unpatched bugs
Show
Long hours spent in debugging issues some time.
Show
Longer build times and pipeline slowness and errors.
Show
Maintaining documentation
Show
Managerial anti-patterns.
Show
Managing dependencies between new and old code bases.
Show
My current level of understanding in the C language can lead me astray at times.
Show
N/A
Show
Never an expert
Show
Never enough time. Crazy deadlines created by others.
Show
Never works first time
Show
No one can help me to debug the issue due confidentially of my projects.
Show
Not understanding what Javier wanted to do some time ago
Show
Often not enough time to go back and perfect the code
Show
Overhead of pushing code to a joint repository
Show
Overhead work. Documentation, source control, maintenance, etc.
Show
Reading codebases with no tests or documentation
Show
Risk and Uncertainty associated with changes. The overwhelming number of edge-cases to test.
Show
Rushed timelines and large amounts of minor changes.
Show
Scale and learning curve is daunting. Too many assertions of a 'right' and 'wrong' way to do things.
Show
So many options to accomplish the same thing.
Show
Sometimes it is difficult to jump into a project that has legacy code
Show
Sometimes not trivial at all. Embedded systems present Operating System and hardware dependencies.
Show
Tedious debugging, unclear errors occurring from typos or small coding syntax errors
Show
Tedious work like documentation.
Show
The amount of time it takes to do things such as documentation and unit testing.
Show
The debugging process
Show
The lack of country/continent-wise recognised certifications ala medicine professionals
Show
The repetitiveness of testing
Show
Tight deadlines, and when the tech lead doesn't want to do anything too complex
Show
To debug issues which are hard to reproduce
Show
Too many abstraction layers that I don't understand
Show
Tricky at times
Show
Trying to explain to people who don't understand software, why building good software is important
Show
Usually it is not possible to find perfect solution and need to compromise
Show
Vendor provided tools
Show
When it doesn't work + all the legacy crap
Show
When something small keeps something from working and is hard to find a patch out.
Show
Working around bugs/issues in vendor provided development environments.
Show
Working with legacy code that uses abbreviations, no comments/descriptions, not very readable.
Show
Working with people that don't care
Show
Working with poorly defined requirements/user stories.
Show
Working with tightly coupled code and code generated by the IDE.
Show
Writing for other people's hardware, working around existing issues
Show
a lot of stuff needs to be learned
Show
complexity that sometimes people do SW, that us caused by a gap in the design and solution grow
Show
dealing with requirements from people that don't fully know what they want.
Show
debugging
Show
debugging, legacy code, spaghetti code, compiling dependencies, cryptic test frameworks
Show
doing unit tests, sometimes we write tests that are not useful, and we do it only for the coverage
Show
gathering requirements
Show
getting stuck in the same step for long time. In one word, debugging.
Show
hard to read/understand code, slow tests, not having enough time to do it properly
Show
having to solve other people bugs
Show
i'd like to do more of it
Show
legacy code mess. lack of documentation. overly complex solutions to simple problems.
Show
long meetings
Show
management's misunderstanding of software
Show
micro-management and having to type
Show
n/a
Show
not knowing why something doesn't work, spending hours on it
Show
running into syntax errors, having to dig too deep to solve a problem.
Show
taking forever to find bugs
Show
testing
Show
that AI can do it now
Show
troubleshooting non software issues related to hardware
Show
unpredictability, it's frustrating when behavior differs from what you imagined while programming
Show
useless meetings
Show