I found an interesting article on the importance of structure (Whether a Project or Folder) within applictions. I will say that when you open a solution and see a list of Projects there names give me an indication of how the application was built. Etc
(MVP Design Pattern example)
- BLL (Business)
- DAL (Persistance (Mappings, Conventions etc) )
- Web
- PL (Presentation Layer)
- Test (Surely tests need to go in a seperate project)
Directory Structure Is Fundamental To Your Code
"As any designer will tell you, it is the first steps in a design
process which count for most. The first few strokes, which create the
form, carry within them the destiny of the rest." - Christopher
Alexander
(Christopher Alexander is an architect. Without having worked as
programmer, he has influenced many people who think a lot about
programming. His early book A Pattern Language was the original
inspiration for the Design Patterns movement. He has thought long and
hard about how to build beautiful things, and these reflections seem
to largely apply to software construction as well.)
In a CBC radio interview, Alexander recounted the following story
(paraphrased here): "I was working with one of my students. He was
having a very difficult time building something. He just didn't know
how to proceed at all. So I sat with him, and I said this: Listen,
start out by figuring out what the most important thing is. Get that
straight first. Get that straight in your mind. Take your time. Don't
be too hasty. Think about it for a while. When you feel that you have
found it, when there is no doubt in your mind that it is indeed the
most important thing, then go ahead and make that most important
thing. When you have made that most important thing, ask yourself if
you can make it more beautiful. Cut the bullshit, just get it straight
in your head, if you can make it better or not. When that's done, and
you feel you cannot make it any better, then find the next most
important thing."
What are the first strokes in an application, which create its overall
form? It is the directory structure. The directory structure is the
very first thing encountered by a programmer when browsing source
code. Everything flows from it. Everything depends on it. It is
clearly one of the most important aspects of your source code.
Consider the different reactions of a programmer when encountering
different directory structures. For the package-by-feature style, the
thoughts of the application programmer might be like this :
"I see. This lists all the top-level features of the app in one go.
Nice." "Let's see. I wonder where this item is located....Oh, here it
is. And everything else I am going to need is right here too, all in
the same spot. Excellent." For the package-by-layer style, however,
the thoughts of the application programmer might be more like this :
"These directories tell me nothing. How many features in this app?
Beats me. It looks exactly the same as all the others. No difference
at all. Great. Here we go again..." "Hmm. I wonder where this item is
located....I guess its parts are all over the app, spread around in
all these directories. Do I really have all the items I need? I guess
we'll find out later." "I wonder if that naming convention is still
being followed. If not, I will have to look it up in that other
directory." "Wow, would you look at the size of this single
directory...sheesh." Package-By-Layer in Other Domains is Ineffective
Source