It all started with such promise.
You carefully chose how to structure your application. You picked a build system, or not, based on your experience and the community. You planned, and thought, and planned some more.
But then something happened: you made a choice. It seemed like the right choice at the time. You were sure! Well, pretty sure. I mean, how bad could it be if you were wrong, right? … Right?
Your app started to feel a little funky after that choice: less clean; less immaculate.
The funkiness increased each time you added more code. After a while it all started to congeal together, like spaghetti noodles that have sat out too long.
You couldn’t tell where your good choices started and where your bad ones began.
What do you do?
300 [email protected]#!&(* Controllers?!
I recently came across a question on the Angular google group asking for help with an app where the author was trying to handle synchronous AJAX calls.
That’s not the part that stuck out to me. Here’s what did:
… I have created almost 300 controllers …
I had to do a double take. Three hundred controllers? Why? What use case could possibly merit that?
Am I an old fogey developer, out of touch with the masses? Maybe separating your logic out into hundreds of tiny pieces is the wave of the future.
Somehow I don’t think so.
First I want to apologize to the person who asked this question.
I’m not ridiculing or chastising you. I seriously want to help you and anyone else who’s gotten themselves into a pickle when creating AngularJS applications. Let’s be honest: that’s all of us.
I have written some absolutely terrible Angular apps that are still in active use in our company. I was new, and learning, and my users bore the brunt of my mistakes. Sorry, users!
Stop, and Reflect
When you’re writing applications and you’ve dug yourself into a hole, sometimes the only thing you can do is start digging another hole. The business won’t pay for you to trash your app and fix your mistakes.
But before you do, it’s important to take a moment for reflection. If you pause for reflection you will deepen the learning experience. The choices, decisions, and process that brought to this place will become more concrete. And then you’ll know that you can make different decisions in the future.
Ask yourself some important questions.
- Is this where I wanted to be?
- How did I get here?
- What choices did I made?
- Would I make the same choices over again?
- What did I choose to not inform myself of or read about? (Best practices, new tools, old paradigms, etc)
- If there were options, how did I compare them?
- How long did I take to make the decision? Was it a snap judgment or a drawn-out process?
It may be easier to work backwards from where you are now, until you reach the point of inflection where your decision train jumped the track. But if that feels overwhelming, just ask the questions above.
It’s important not to critically follow your decision breadcrumb trail, questioning yourself at every step.
Instead, what you want is better self-understanding: to see how you make decisions; whether you’re impatient or controlled, risk-adverse or venturesome, methodical or chaotic.
None of these character traits is good or bad, but if you know how to tend to act you can self-modulate in advance, protecting yourself from making similar mistakes that arise from your behavior patterns.
When you do this sort of reflection it’s important to be gentle with yourself. Beating yourself up and calling yourself names in your head is absolutely not going to help you learn and improve.
Accept the situation for what it is: a chance to learn and grow. You will be a better developer for this experience. It is the uncomfortable places that stretch us where we grow the most.
How Did He Get Here?
Our author above didn’t start with 300 controllers.
They most likely grew our of a combination of two things:
- A decision that single controllers were the right place to put distinct bits code
- A whole bunch of distinct bits of code
Each time the author had a new thing to add to his app, he fired up ol
app.controller() and went to town.
At some point he had 5 controllers handling some parts of his application. Perhaps they were all centered around a certain section and he needed to jump to another. Bing! five more controllers. The process continues as he grows his app: 20 controllers, 50, 100, 200.
What the author is seeing and saying to himself is not “man, that’s a lot of controllers!”, rather “man, that’s a lot of work and business logic!”.
Do It Different
How would you handle this situation differently? What are the patterns, best practices, and experiences that you can apply to this situation?
Could you use generators to create controllers? If you can make them through simple configuration then they should be generate-able as well.
If they are configurable then maybe composing different pieces together with nested views in UI-Router could be the best thing.
If the controllers represent different little widgets then directives are probably the answer. And you can always stack directives as well. You can create generic directives and have more specific ones stack functionality.
Do you have another idea? Share it in the comments section below!