Training Preparation -- What 100 Attendees Dislike About Software Development

Least favorite thing about dev

Show
-
Show
- slow deployment/testing
Show
Agile
Show
All the documentation to go along with it. And UL.
Show
Banging my head against a wall chasing down bugs for hours at a time.
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
Bugs and writing lots of documentation, usually.
Show
Business challenges that slow down or stop you from developing.
Show
Clunky tools, anacronyms of C
Show
Commenting code
Show
Complex and emergent behaviors
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
Deadlines
Show
Deadlines set without a good estimation process
Show
Debugging
Show
Debugging can be difficult and time consuming and/or I write myself into an architectural corner.
Show
Debugging is fine, but doing it under time pressure is awful (which is normally the case)
Show
Estimation
Show
Examine/Debugging others code
Show
Fighting with the initial setup of a testing toolchain
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
Hard to find bugs.
Show
How much time is spent trying things until it works and how brittle it often is.
Show
I don't enjoy working within a codebase that doesn't apply software development best practices.
Show
I like
Show
In medical -- the long time it takes to develop a few lines of code.
Show
It can be frustrating.
Show
It can feel like a grind sometimes
Show
Lack of documentation/requirements
Show
Libraries that contain unpatched bugs
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 code from last year backwards. I will think the same next year
Show
My current level of understanding in the C language can lead me astray at times.
Show
N/A
Show
Never enough time. Crazy deadlines created by others.
Show
Never works first time
Show
Not getting enough time for research or improving solution.
Show
Nothing really. Perhaps fighting with tools that doesn't work or slows down your work
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
Slow development environment, tedious tasks (boring debugging included)
Show
So many options to accomplish the same thing.
Show
Sometimes it takes very long time to see the results - medical industry...
Show
Spending more of my time working with machines instead of with people.
Show
Tedious debugging, unclear errors occurring from typos or small coding syntax errors
Show
Testing. Solitary. Long time in a chair. low interaction with other people.
Show
That I eventually get tired and have to stop.
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
Too many abstraction layers that I don't understand
Show
Trying to explain to people who don't understand software, why building good software is important
Show
Unnecessary complicated code, and arch, left by devs trying to be clever.
Show
Usually it is not possible to find perfect solution and need to compromise
Show
Vendor provided tools
Show
Waiting for long builds or tool runs.
Show
When something small keeps something from working and is hard to find a patch out.
Show
When the code gets way to complicated and hard to debug.
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
Writing for other people's hardware, working around existing issues
Show
Writing unit tests
Show
a lot of stuff needs to be learned
Show
context switching
Show
debugging
Show
debugging
Show
debugging, legacy code, spaghetti code, compiling dependencies, cryptic test frameworks
Show
hard to read/understand code, slow tests, not having enough time to do it properly
Show
i hate debugging, and getting sucked into writing a bunch of code at once, instead of incrementally
Show
i'd like to do more of it
Show
iteration takes long time.
Show
long meetings
Show
management's misunderstanding of software
Show
micro-management and having to type
Show
n/a
Show
no
Show
not knowing why something doesn't work, spending hours on it
Show
pressure to deliver bug-free software within short time frame.
Show
running into syntax errors, having to dig too deep to solve a problem.
Show
taking forever to find bugs
Show
testing
Show
troubleshooting non software issues related to hardware
Show