Hacker News Reader

Comment by dons | Hacker News Reader

> The core app is 9K lines of code.

I don't think 9K is "large" for an application. At all.

I'm not sure what you're comparing this to but 9,000 lines of well-written code in a powerful MVC framework is a very significant size.

Because there is so little boiler-plate code that is being written, the utility-density of such a codebase can be extraordinarily high. 9,000 lines of PHP could amount to very little utility but when well-architected, there is a crazy amount that can be done with even 2,000 lines of a framework such as Angular or Rails.

[EDIT]

The point I'm making is that a good developer working in harmony with a framework can do in 4 very readable lines what a less experienced developer might easily expand to 60 lines. As such dismissing a 15k codebase as "small" is somewhat naive. A 15k Angular app can do a vast amount.

My experience with Rails (and my limited experience with Angular suggests it's similar) is that working harmoniously with the framework gives you massive amounts of utility with very, very few lines of code. I've personally refactored 100 line controllers from junior developers down to 12 lines. It might feel macho to compare codebase sizes but there's no strong coupling to utility (arguably perhaps the reverse).

You can certainly write 60k apps in Rails, Angular or Django but dismissing a 15k app as "small" doesn't do justice to the utility that even such a "small" codebase can deliver.

...sorry this comment was so long I didn't have time to write a short one ;)

Much of Angular's power comes from its declarative syntax. Much of the time, you set down what you want to happen, and not how.

The problem is, it's not always obvious what "the Angular way" is, but on the plus side, I've just thought of a title for a series of blog posts...

Example: I'm working on a "large" CakePHP application (similar to Rails) with 24,000 lines of our own code, 57,000 lines of code from community plugins, and 240,000 lines of core framework code.

It would be 2-10 times less lines of code on Django (and also on Rails). Lines of code comparisons do not scale between programming languages.

I'm not sure I agree. All the frameworks just mentioned do more or less the same thing and have comparable lines of code counts.

- Django - 215,000 LOC (.py)

- Ruby - 232,000 LOC (.rb)

- CakePHP - 240,000 LOC (.php)

Rails is about 110,000 LOC, last I checked right before the 4.0.0 release, where'd you get that number?

$ git clone https://github.com/rails/rails.git && cd rails

$ find . -name '*.rb' | xargs wc -l | tail -1

232424 total

Maybe I should have said LOCC (lines of commented code)?

That does include all of their unit tests code though. I wouldn't personally define unit tests as "core" framework code since I can deploy a Rails app without them (they never show up in a stack trace). It's going to come down to your own semantics since Rails wouldn't exist as it is today without them either.

Ahhh, you know what? I just realized I was confused: the diff for rails 4 was about +110,000 / -100,000, that's what I'm remembering that number from. My bad!

>>It would be 2-10 times less lines of code on Django (and also on Rails) [Compared to CakePHP].

Interesting claim. Do you have references?

(An account with a couple of hundreds of Karma making extreme claims? Please surprise me by not being a troll. :-) )

I am the sole maintainer of a framework free PHP codebase with ~100K lines. Who's jealous?

It could probably be rewritten down to about 10-20K lines (maybe less) if I had a spare month or two.

If you are saying the size of your application could be reduced by rewriting it to using a framework (an existing one or one of your own creation), I think this is the point we are all trying to make here.

Assuming one uses all the features of a framework, the total complexity of my 24K line framework application (counting only code I've written) could be compared to that of a 321K line non-framework application (counting all the code in my project).

Thankfully I only have to write/maintain 8% of the codebase, as the remaining 92% is kept up-to-date by typing `composer update` on a weekly basis.

In this case, simply refactoring to remove duplication would probably work. For example there are at least 3 different ways to send email.

There is a lot of code in there that is really "framework" but it's completely baked into everything else so not really separable. There's probably at least 2 different and distinct attempts at creating a framework, and you can tell the age of the code by which it uses.

The main reason it hasn't been significantly refactored is that it is astonishingly reliable considering how bad the code is.

I think 9K lines of code using framework which is meant to be "high-level" is a pretty big code base.

9K LOC (not including comments) may not be "large" but it is quite sizeable and in a framework like Angular, probably does quite a bit.

For comparison, I work on a Backbone.js app that has the following distribution.

  --------------------------------------------------------------------------------
  Language                      files          blank        comment           code
  --------------------------------------------------------------------------------
  Javascript                      282           4348           7356          27860
  CoffeeScript                    336           4953           1687          17939

Obviously Backbone.js has much less "batteries" included.

The tips in the article were good and well thought out. I appreciate the effort the author made.

What did you use to generate this LoC analysis?

Looks like the output of cloc

The small team I am on just re-wrote a number of different apps written by 3rd parties that were 20/30k and got them down to ~3k -- mainly by throwing out all their library junk and just doing things right in AngularJS.

Currently our AngularJS application is 20k lines (between controllers, directives, services, and templates) and it certainly feels like a large application -- not when working on it, but when using it. AngularJS makes it very easy to build quite "large" (in the complexity/richness sense) applications with much less code than most other approaches, in my experiences.

Of course, if we are treating size as absolute, and basing it on lines of code, then 9k is pretty small. I mean linux has like 15m lines! It will take a while to catch up.

Our largest Angular app currently has a 2500 line controllers.js file. There are about 20 controllers in this file. I've thought about splitting it up into multiple files, and I think I'm going to do that.

However, right now it works quite well since I'm using "editor folds" to separate each controller.

It is for JS. At least if you consider all the other "built with Angular-js" examples so far (except for Double-Click maybe).

For a C++ or Java code that 9K would probably make it into the "small" category.

Agreed. It's probably closer to small. The insights are still worth considering, however.

Reply on news.ycombinator.com