|
What of the velocity of lines of code written over time.
Early on, you might write lots of lines of code. say 1000 lines. push to release.
sum = 1000
But 200 of which is bad. So rewrite those. RELEASE!
sum = 1200
Then you refactor. cutting out 400 lines. Release is now 600 lines. RELEASE!
sum = 1200 + 300 (not 400 as rewrote some multi lines as singular lines) = 1500
Project 2. Very Similar to Project 1. But know you know mistakes. And some extra feature. Same amount of time. 600 lines. RELEASE.
sum= 2100
Year 1. 1500 lines.
Year 2. 600 lines.
Then you build a library of reusable stubs, which you reuse.
Released lines of new code I would say goes down.
Maybe some increases when figuring out a new language.
Oh, but released lines of code would tend to increase. Because that library of support code you use to reduce the amount of new lines you need to write, will increase and bloated to cover the odd and weird corner cases it needs to satisfy.
|
|
|
|
|
sum = impossible to know how many
It's a silly question to be honest. With your examples, plus any IDE (or other tools) auto generating code, where do you even begin to start counting...
(well, I guess technically you start counting at 1)
|
|
|
|
|
stupid metric.
I don't write effective (wrong word here) line of code that often, most of the time it is generic boilerplate code to make those those effective line of code work.
I'd rather be phishing!
|
|
|
|
|
write lines of code??? why?
post question to CP/SO, wait for replies (check for flames on newbie answers)
cut
paste
ZERO lines of code written.
Message Signature
(Click to edit ->)
|
|
|
|
|
|
That's awesome!
I rather suspect that Lee Child, Bernard Cornwell and a fair few others have used up all of theirs by now but their novels keep coming on a daily basis, so I guess they must be using voice recognition software.
Whenever you find yourself on the side of the majority, it is time to pause and reflect. - Mark Twain
|
|
|
|
|
|
Reacher said nothing.
He could tell from the grease stain on the safety-catch that the Glock XP3-15 had been fired three times, yet he had only heard two shots. The smell from the muzzle indicated that the first shot had been fired 42 minutes and 17 seconds prior to the first. Given that the truck had been heading east at an average of 45 MPH, he knew for sure that this was the weapon that had killed Jackson in the warehouse in Topeka, the gun being held at an angle of about 15.6 degrees so that the shell would have severed Jackson's cerebral cortex instantly.
The FBI forensic team duly resigned as they felt so crushingly unnecessary ...
(I actually really liked the couple of Reacher books I read, but how many do we actually need?)
Whenever you find yourself on the side of the majority, it is time to pause and reflect. - Mark Twain
|
|
|
|
|
Apparently I still have 34 novels left.
I'd better get started... "It was a dark and stormy night..." ![Java | [Coffee]](https://codeproject.global.ssl.fastly.net/script/Forums/Images/coffee.gif)
- I would love to change the world, but they won’t give me the source code.
|
|
|
|
|
I've heard that about thirty years back (when C was more dominant), some managers used to have tools to count the number of semicolons, each semicolon signifying a line as productivity tools. So, some developers used to have lines as
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
which is as many lines of code.
|
|
|
|
|
for loops counts as 3 lines. glad i barely use linq. LOL
When I was growin' up, I was the smartest kid I knew. Maybe that was just because I didn't know that many kids. All I know is now I feel the opposite.
|
|
|
|
|
let's see. I've written about 10,000 lines this week (strangely enough, I've been counting, and working on a single project so it's easy)
gosh. im my life? I've been coding for about 32 years
I type faster these days, and have a lot of time to do it these days.
and I can crank out what, 520,000 lines a year if I apply myself.
*32 years = 16,640,000 lines of code. we'll halve it.
8,320,000 so far.
i've probably got another 10 million in me.
When I was growin' up, I was the smartest kid I knew. Maybe that was just because I didn't know that many kids. All I know is now I feel the opposite.
|
|
|
|
|
120,325,116 lines of code....no less, no more. duh. easy question, next?! 
|
|
|
|
|
I'm finding that as the years go by, I'm writing less and less new code. That is to say, I encounter fewer situations that I haven't already dealt with. Being lazy, this leads to either copy/pasta and probably some customization, or better the creation of a reusable utility function.
Also, the IDEs, particularly intellisense are so much better these days than when I started...this code was generated by a tool. 
That said, a rough estimate would be around 1.8M in 20 years, around 90K/year average, but as stated, the majority would have been written in the first half of that time frame.
"Go forth into the source" - Neal Morse
|
|
|
|
|
When the VAX supermini was every programmer's dream, DEC published statistics showing that the average production volume for those developers writing the microcode for the 780 (the firs one in the VAX series) was 250 (micro)instructions a year.
Everybody knows that you do not leave microcode writing to the novices - those programmers were among the very best that DEC had. Yet it took them, on the average, a full day's work to figure out a single instruction.
Since the 780 was the first crop, I guess lots of the effort went into competence building, learning the tools etc. Maybe it even included some tool development. I don't know how DEC did the counting, only that the total number of microcode instructions produced divided by the number of microcode programmers returned about 250 instructions/year per programmer.
|
|
|
|
|
Approximately 1,243,867, but only 12 without bugs.
Technician
1. A person that fixes stuff you can't.
2. One who does precision guesswork based on unreliable data provided by those of questionable knowledge.
JaxCoder.com
|
|
|
|
|
"Lines of code" is a rather meaningless metric, since you can rewrite a line many, many times. And what constitutes a "rewrite of a line" anyway, if a single line then gets broken down into multiple lines (or vice-versa) after some refactoring?
|
|
|
|
|
Wouldn't it be more interesting how many keystrokes you typed?
if (i==1)
vs
var result = MyWonderfullData.Where(x => x.FullNameWithoutSpaces).Select().OrderBy().Etc().Etc()
makes quite a difference 
|
|
|
|
|
My whole career was spent programming. My first full-time job after university was in 1972, aged 21. I retired in 2017, aged 66. So I worked for around 45 years. I used to count lines of code at various points and my estimate was that I created around 30,000 lines of debugged production code per year. In the early days it was assembly code. Later it was Pascal, C, C++, Java, VB, C#, Objective C, etc. I think the line count remained the same. I was just more productive in the more recent technologies. So whereas my 30000 lines of assembler code for a PDP11 might have occupied 64KB and was the only code running in the machine (no operating system), my final applications occupied tens or hundreds of megabytes, especially with all of the libraries they brought in.
So if I did 30,000 LOC per year for 45 years I must have produced well over one million LOC in my career.
And thinking back on the last 2 decades I would say that at least 300,000 of those lines are still in production: 1 desktop app, several Android apps, 1 IOS app and a good proportion of a SAAS webserver-based app.
I do not think I ever wrote 10000 lines in a day, even on my most productive day. I guess I often did 1000 or more, especially when it involves a lot of copy/paste/edit. But that was balanced by other days where the emphasis was on meetings, planning, testing, debugging etc. I find it hard to believe that anyone personally (i.e without machine aid) created 10 million or more LOC in a career. E.g. 45 years of 40 hour weeks and ignoring holidays is only 336 million seconds so 10 million LOC would mean creating one line every 33.6 seconds.
modified 26-Jul-19 6:07am.
|
|
|
|
|
All of these different methods are simply a volume metric and are roughly correlated. But, consider that for a blank link you have to hit the enter key. For a comment, you actually have to type it. For code you also have to type it. For both code and comments you have to think about it and since the comments are about the code, that is relevant. Documentation outside of code also counts in the same way, but probably stripping off the formatting is reasonable. So, simply take the size in bytes of all of the source files. Perhaps it would be worth while to compress each one and then total the size. That would tend to reduce the effect of spaces / tabs and repeated variable names and the length of variable names. Compressing everything together would result in too much reduction in size due to similarities across programs that don't really reflect much.
I have found that, in practice, a simple volume metric is a very good predictor of performance and and time required to complete a project.
|
|
|
|
|
A parallel: Technical writers produce 1 page per working day.
At least when I was working with documentation, that was commonly accepted, both by writers themselves and management. It matched our writing department quite well.
30+ years ago, documentation was 98% text, produced with rather primitive tools. Later, modern tools made it much easier to add graphics and other illustraion, typographical effetcts etc. which made the documentation look more "professional" quality. But in spite of more automated and fancy tools, production as measured in pages per day didn't increase: Making a figure to illustrate a point takes as much time as describing it in text.
I haven't been in documentation for years, and nowadays, I guess most software documentation is written by the programmers themselves (so it makes no sense to the users...), and counting number of pages for online documentation is not as easy.
I guess that you will see much of the same as programming languages evolve: The line count produced by an assembly programmer, a K&R C programmer, a Cobol programmer, or a C# programmer would be roughly the same, even though the functionality provided by those "x" code lines vary greatly. There are some obvious exceptions, such as microcoding or APL, but for the algorithmic class of languages, it seems like the variation in line count is not that great.
|
|
|
|
|
To paraphrase Bob Dylan:
"How many lines must a programmer lay down,
Before his lifetime is done?
The answer my friend is blowing in the wind...."
|
|
|
|
|
I'd like to add the most wonderful blues for developers, from Simon and Garfunkel:
Hello Source code, my old friend...
I've come to talk to you again...
Because a vision softly creeping
Left its seeds while I was sleeping
And the vision that was planted in my brain
Still remains
Within the code... on servers...
|
|
|
|
|
I saw Paul Simon on his farewell tour and he's terrific!
A little John Kay and Steppenwolf back at you
"Code me baby, code me baby All Lifelong"
|
|
|
|
|
I'm writing poor code, nobody loves me
"HE'S WRITING POOR CODE FOR A POOR LIBRARY SPARE HIM HIS FAILS AND HIS DEPENDENCY!"
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
