its not -- its called "ramp up" time. its usually about a day or up to 2 weeks depending on the size of the project before you feel comfortable making changes. the longest one i ever had was about a year, where after i worked on a project for a year i was still finding sections of code and saying "oh... i had no idea our app did this or these files were there!"

usually the dev will just poke around for that time and make small changes and debug it a few times to see how it works. 4-5k lines i would say 2-3 days tops before they are comfortable with it.

Not all developers are as good at reading other people's code as you are. Some developers who are good at writing code from scratch are not very good at reading existing code (even code that's not messy) - reading code is a completely different skill than writing code and requires a lot of patience and concentration. Many developers will just throw up their hands and claim the existing code must be thrown away and rewritten from scratch.

So, the answer to the question "How hard is it for a qualified developer to take up an existing project with messy code?" is: "it depends". It depends a lot on the developer's skill at understanding and refactoring code. It depends on how messy the code base actually is. It depends on whether the original application had any unit tests. It depends on the complexity of the application. It depends on how well you can explain to the developer what the original version of the code was actually supposed to do.

"usually the dev will just poke around for that time and make small changes and debug it a few times to see how it works. 4-5k lines i would say 2-3 days tops before they are comfortable with it."

It really depends what the OP means by messy. If by messy he means fairly straightforward code but not built for easy extension and lacking proper layout/architecture then a few days is enough.

On the other hand if by messy he means complex code implementing requirements in a non-obvious way then it could take much longer. I've seen plenty of code that uses multiple layers of indirection when a simple switch statement would suffice. Where code that looks like a simple mistake is actually implementing a critical requirement. Where you have to keep multiple heavily abstracted domain models in your head at once to understand the code because there is no clean separation.

It depends on how well you need to understand the code to be able to make changes. Reasonably well written code can be skimmed at speeds of up to 2500 lines of code an hour and only the core domain objects and algorithms need more intense study.

On the other hand if you have to understand the entire codebase in order to change it then 100 lines of code an hour is an upper limit.

So anywhere from half a day to two weeks depending on what you mean by messy.

I can understand what most of the code does and I am really an amateur. So I think it is more along the lines of "fairly straightforward code but not built for easy extension and lacking proper layout/architecture then a few days is enough."

Thanks for the input! I appreciate it.