Comments on: Who maintains your JS?

By: Connor dt

Connor dt — Fri, 16 Aug 2013 04:29:47 +0000

It occurs quite a number of times with me when I write a script or a program in the past only to look at it after few weeks or months with no idea what’s going on in the code.The reason is I develope a large structures of complex codes/blocks almost daily with my team and it tends to happen that I myself don’t recollect which logic had I applied for that particular code at that particular time in the past.Though I am confident to break down my own code,I would cite this as a little time consuming process.That time which we could constructively use for developing other blocks if we had included comments,at least for some confusing and complex logic.For me,’Time is Money’ and I can’t afford to waste it.Also one can mention some useful notes in the form of comments for future reference like the reason for choosing that particular logic while there were other options possible for writing that particular code.Also then advantage of using comments for its ability to remove bits of code from execution when you are debugging your scripts,persuade the
maintainers to use it quite often.

By: Rebecca

Rebecca — Tue, 30 Jul 2013 10:02:56 +0000

I can see there is a mixed opinion for this topic where few people think writing comments is absolutely necessary while others think it is purely a waste of time,efforts and money.According to me,it completely depends upon one’s profession.If you are a tutor and the student is level one maintainer has absolutely no knowledge or experience,commenting becomes very much necessary which the tutor has to do as it is his job.Similarly,the same practice has to be implemented in case of a new employer,new learner,new client.
But at the same time,I sincerely would emphasis on lessening this practice by the tutor/group leader/high level maintainer in future to allow the beginners to learn,interpret,break code on their own.I am strictly against the ‘spoonfeeding’ and would want to let them use their brain in developing logic,deciphering the code.

By: Jack

Jack — Fri, 19 Jul 2013 02:07:10 +0000

And speaking about writing comment in code.

“Every time you write a comment, you should grimace and feel the failure of your ability of expression.”

“Good code is its own best documentation. As you’re about to add a comment, ask yourself, ‘How can I improve the code so that this comment isn’t needed?’”
– Steve McConnell

By: Jack

Jack — Fri, 19 Jul 2013 02:03:39 +0000

“ Any fool can write code that a computer can understand. Good programmers write code that humans can understand. ” – Martin Fowler

I just remember this one while programming. Nothing else.

By: Lewis Autumn

Lewis Autumn — Thu, 04 Jul 2013 06:31:17 +0000

First of all,the categorisation of maintainers you made into level 1 to 6 is just spot on.I believe in ‘Practice makes man perfect’.I work as a tutor for training new recruits in various companies and hence deem the beginner as level 1 maintainers who have knowledge and programming skills probably even higher than level-1 but lack in experience and ultimately in confidence too.For such maintainers,I prefer to write comments for every simple and difficult block enabling them to break and fully assimilate the code.As the time progresses,their practice,experience will definitely place them higher than level 1 to at least level 4 or even higher depending upon the expertise,knowledge and the aptitude the person has.Once he reaches that stage,there is absolutely no need to write any comments even if the code is difficult to comprehend.Here the judgement to appraise and estimate the maintainer level is a big task and it can vary person to person.

By: Rachel Jones

Rachel Jones — Wed, 26 Jun 2013 06:21:41 +0000

One can write multiple codes for the same programme in context with one’s own point of view to develop the code.I myself have found writing drfferent codes for the same programme when given to me few days after writing the first one.Interestingly both are logically correct but both reflect ideas to construct the code which are not similar to one another.In such cases from a reader’s point of view,a need to put comments feels indispensable in order to comprehend the code and absorb the logic of the maintainer.In a similar fashion,I think it is absolutely uncertain to expect from your colleagues to help you estimate a maintainer level.

By: Audrey normes

Audrey normes — Fri, 14 Jun 2013 07:07:44 +0000

I guess it depends upon what application/purpose you are writing the code for.I would consider a good developer to write the
explanation in the form of comments in order to leave no room for
ambiguity and confusion as there are many ways a person could
think of,while developing a code.It is considered a good practice if it is to be presented to the students from a teacher or presented as a report to the client from an employee no matter how easy or difficult the code is to perceive.
I agree that for a JS maintainer at level 5 to presume the future
readers at the same level is not fair and justified.Also on few occasions,the people you are working with are not capable enough
to help you draw the estimation of an appropriate maintainer level.For me this topic is very subjective and debatable.

By: Thomas Faith

Thomas Faith — Fri, 07 Jun 2013 09:02:47 +0000

As a student,I have been taught to comment the code whether it is really difficult to interpret or not.An expert could grasp it well without a need to even have a look on the comment unlike a beginner one.But as a tutor,I feel the necessity to use a comment to make my students learn and understand the concept and even the smallest nuances in a better way.
I liked the categorization of developers at different levels.I guess a good developer is definitely capable of doing tasks mentioned at level 5.

By: Marcus Stade

Marcus Stade — Tue, 07 May 2013 17:23:08 +0000

Dear Juan Mendez,

There’s a very real possibility you’ll never have to deal with my code, ever. I’m fairly certain this won’t have an adverse effect on your life or career, just like it won’t matter much to me either. In fact, I couldn’t really care less. Glad we got that out of the way.

I have never in the span of my career had to fix a bug that was hard to track down – which is what I assume you mean – because the original author had expert knowledge that more often than not comes from years of professional, validated experience. On many occasions have I come across code I didn’t understand. As a more inexperienced developer I often swore over it, but these days I find it curious. It’s like coming across a piece of prose, the meaning of which is yet to be determined. In the end, I generally learn something from it; even if the lesson learned is that the code is incompatible with my palate and thus won’t be something I’ll produce. These days I never lament having to deal with someone else’s code. If I don’t like it, but understand its meaning and can verify the end result (i.e. test it) I’ll quite likely just rewrite it – if I care enough that is. Life is short, my time is probably better spent elsewhere.

My point is that in the end these things are subjective, and it doesn’t matter much in the grand scheme of things. Certainly not if you’re on your own. If you’re part of a team, it’s more important to have the team jell and what you refer to as coding standards and practices will just naturally evolve. At least, that’s the experience I have from working on several successful teams, and even more unsuccessful ones. The latter usually decides to spend time to codify standards and processes; the former just works.

Oh and the name is Marcus Stade – not Spade. Glad we could get that sorted out as well.

By: Juan Mendes

Juan Mendes — Thu, 31 Jan 2013 00:59:42 +0000

Don’t assume everyone knows all the language tricks like you do. I think the best way is to establish best practices for a company, everyone may not agree, but everyone will code mostly the same way. I hope I never have to maintain/edit/delete/rewrite code that Marcus Spade wrote (since he doesn’t care about future maintainers). Marcus Spade, did you never have to fix a bug that was really hard because the original coder had some mysterious assumption in their code? Or because you weren’t quite sure of the precedence rules and wished they had put in some extra parentheses?