By: Ben Hosking
Improving as a Dynamics 365 developer takes dedication and persistence. It takes years to build up your experience and knowledge but you can speed up the process by learning from the mistakes and experience of others.
No shortcuts
Becoming a good Dynamics developer is difficult and takes time, which is why there are few good Dynamics developers.
It involves focus, effort and learning from your mistakes. It takes time for your skills, knowledge and experience to accumulate and learn from your mistakes.
Aim to finish work wiser about Microsoft Dynamics than you when you started. Each day learn something new, improve your skills and reflect on your experiences:
If you want to be a better coder then commit to being better and start being a better coder now #HoskCodeWisdom
There is no shortcut, only time and dedication. Warren Buffett talks about Charlie Munger and his focus:
“Charlie, as a very young lawyer, was probably getting $20 an hour. He thought to himself, “Who’s my most valuable client?” And he decided it was himself. So he decided to sell himself an hour each day. He did it early in the morning, working on these construction projects and real estate deals. Everybody should do this, be the client, and then work for other people, too, and sell yourself an hour a day.”
Enjoy being a Dynamics developer
“You must understand the following: In order to master a field, you must love the subject and feel a profound connection to it. Your interest must transcend the field itself and border on the religious.” ― Robert Greene, Mastery
If you don’t enjoy Dynamics development you will find the work boring and the days long. If you are not passionate, you won’t care enough and you devote the time needed to improve.
Want to improve
Development is difficult but rewarding when you do it well #HoskCodeWisdom
Improvement comes from within, it‘s a desire to get better. You need a passion for development, keep motivated, know why you want to improve if you don’t have a good reason you will give up.
It’s a slow process of continuous improvement, end each day learning something new or improving skills or sucking less each day. Junior Dynamics developers struggle with the limitations of Dynamics 365 functionality, often creating a customisations only to find due to a limitation the solution won’t work.
A student mindset uses opportunities to learn and improve, the more experience and knowledge you build the fewer mistakes you make.
“Most people don’t have the patience to absorb their minds in the fine points and minutiae that are intrinsically part of their work. They are in a hurry to create effects and make a splash; they think in large brush strokes.
Their work inevitably reveals their lack of attention to detail — it doesn’t connect deeply with the public, and it feels flimsy.”
― Robert Greene, Mastery
Reflect
Learn from your experiences, review your mistakes you and avoid repeating them. Inspecting how you work, adapting and keep improving.
Learn from your mistakes, identify patterns, catch yourself from being busy but not productive.
The person who doesn’t learn from their mistakes, repeats them. Don’t waste your experiences, make them count.
Keep code quality high
Read Clean Code: A Handbook of Agile Software Craftsmanship. To write simple code you need to understand design principles, they decouple code and avoid making code brittle.
Brittle code with large methods is hard to understand and breaks. When you change one line of code, it breaks other unrelated parts. Controlling dependencies and decoupling code allows you to manage code change.
Naming is important, go back over your code and improve the names of variables, methods and classes. Like writing a book, developers never give the best names in the first draft, it‘s important to edit, refactor and refine your code. The first draft gets it working, further drafts are to simplify and improve readability.
- 7 Design lessons for a developer
- How do you know your code is bad?
- Writing clean code
- Steps to better code
- Good coding practices — Information hiding
- Why Code Readability is important
Design code
Don’t just write code. Think about it, design it, write it, refactor it, be proud of it #HoskCodeWisdom
Before you start typing, spend time designing your code, find classes and abstractions. Designed code is easier to read, debug, reuse, unit test, maintain and extend. All code has an impact, well-designed code minimizes dependencies
- Why understanding abstractions can help you write better code
- Understanding levels of abstraction can improve your code design
- How to find classes
- Are CRM Developers are afraid of creating classes?
- CRM 2015 — CRM developers should think in Entities
- Are your CRM plugins creating technical debt?
Understand SOLID principles
SOLID principles are the building blocks of good code. You will produce better quality code, fewer dependencies, and fewer problems later. SOLID principles help developers recognise good code.
- Uncle Bob Principles of OOD
- SOLID architecture principle in C#
- SOLID — the first five principles of object oriented design
- Wikipedia SOLID
Help yourself
Don’t suffer in silence and sit frozen in front of the code, don’t waste time not making progress. Don’t ask for answers, ask to be pointed in the right direction. Software development has lots of dead ends, to solve problems you must rule out options and clarify assumptions.
Resolving your own problems is time-consuming, be pragmatic and know when to spend the time learning it yourself and when to get help.
A useful tool is to describe my problems to a toy/cardboard developer, explaining the problem to the toy and myself I can uncover the solution and I avoid wasting other peoples time.
Why all developers should be friends with a cardboard developer
Seek out what you are weakest
Improve knowledge and skills, build up your experience. Don’t hide from these, focus and improve. Use weaknesses and mistakes as triggers for learning.
Its better to learn functionality before it’s needed on a customer project, where the pressure is on and deadlines are looming.
How to cope when you are out of your Developer comfort zone
Learn from colleagues
Fellow developers are walking, talking troves of knowledge and experience, learn from their experience.
Colleagues might be useful sources of knowledge but don’t ask them for help without trying to solve problems yourself. Solving problems yourself gives you the solution and the learning.
The goal is to create customisations delivering the required functionality but it‘s the journey which improves your skills. Create customisations and get senior developer to ratify your solution.
All developers have tips, tricks and shortcuts which can help you, if you ask and talk to them.
Talk Dynamics 365
Talk Microsoft Dynamics 365 with your colleagues and you will learn something or at worst give information to someone else.
Share knowledge with the team and work together to create a broad knowledge of Dynamics 365 bringing in your differences experiences and thoughts.
Get Certified
Certifications give a more rounded and in-depth knowledge of Dynamics 365. Investigating functionality in Dynamics 365 which they no practical experience of.
Dynamics 365 is the developers main tool, they should know it inside, outside, up and down.
- What are the benefits of CRM certifications
- CRM 2013 — Why you should take and pass the Configuration and Customization Certification
Studying for Dynamics certifications helps to understand the limitations of Dynamics 365 functionality. Limitations are key factors when deciding the right customization for a requirement.
Average is not good enough
Developer skills are like a snowball, they start off small and quickly pick up speed as your knowledge and skills grow #HoskWisdom
Don’t do average work, do great work. Customers and other developers can quickly tell if someone is delivering quality work. Good developers code works well and anticipates the needs of the users, it contains fewer bugs and when bugs are fixed they don’t bounce back.
Developers who work too quickly often don’t fully understand the requirements, don’t clarify them and deliver what they think the users want. The code contains assumptions and bugs and never seems to be finished
Deliver code you are proud of