How to Grow as a Developer

Ailete619 — Fri, 30 Jan 2026 08:52:04 +0000

Growth isn’t innate or genetic. It’s a set of habits you practice when nobody is watching — especially when things are messy, unclear, or uncomfortable.

1. Don’t ask for permission

Don’t wait for invites or approval to improve things — start.

Don’t ask your manager if you can write the RFC — write it.

Don’t wait for an architecture meeting — propose a solution and put it in front of the team.

Initiative is a skill. Use it often.

2. Navigate around obstacles

When something blocks you, ask: “How do I go around this?”

Don’t wait for “the cleanup sprint.” Document the mess, identify the risks, and propose a plan.
Progress usually comes from the person willing to move despite imperfect conditions.

3. Keep receipts — for you, not for your manager

Don’t complain about the lack of feedback. Build your own evidence.

Keep a running document and update it weekly:

wins and impact
bugs fixed and incidents avoided
decisions made and tradeoffs considered
projects shipped and outcomes

Add links where possible (PRs, docs, dashboards, incident reports).

Not for bragging — for proof and leverage. When promotion time comes, don’t rely on memory. Show the data.

※ Also: document your work so others can learn from it. Architecture Decision Records (ADRs) help transmit context. When people leave without documentation, knowledge leaves with them.

4. Embrace the beginner’s mindset

You don’t need to know everything before doing anything — and you don’t need to pretend you do.

Say: “I don’t know yet, but I’ll figure it out.” Ask for help early, then learn fast. Treat every problem like a learning opportunity.

※ A simple practice: every week, pick one new thing — a design pattern, a business concept, a tool — and spend a few hours understanding it. Not mastering it. Just building familiarity. Repeat.

5. Compete against yourself

Your real competition is who you were six months ago:

Are you better than you were?
Are you closer to your goals?

Every three months, write down what improved, what didn’t, and what you’ll change next.

6. Set boundaries

Audit your environment. Reduce time with “anchors” who constantly complain, blame, or interrupt. Protect your attention — it’s a precious resource.

Make room for:

uninterrupted focus time — do the hard work without context switching.
silence — let your brain think without input.
deliberate practice — improve a specific skill on purpose, not by accident.
recovery — recharge so you stay sharp and performant.

You can’t grow if you’re always being pulled into noise.

7. Take ownership of problems

Stop blaming others for everything that’s broken. Ownership doesn’t mean doing it alone — it means choosing a response.

※ A useful reframe: start complaints with “I haven’t figured out how to…” That shift turns frustration into action and invites collaboration. Teams solve more when people speak in problems and next steps.

8. Learn the business

Don’t focus only on the tech stack. Great engineers understand how the company makes money — and where it loses it.

When you know the business model, you design systems that protect revenue, reduce cost, and improve outcomes that matter. That’s how your work becomes obviously valuable.

Japanese

Blazor Server: Use reflection to automatically fill email templates

Ailete619 — Thu, 18 Apr 2024 08:28:48 +0000

Introduction

I'm currently developing a web application that uses email templates at work. The email templates are stored in the database.

All templates require two types of information to fill in the blanks:

Information about specific database entities
URL generated from the current domain, information from the above entities, etc.

However, not each template requires exactly the same information.

I started by writing a method for each template to extract the required information and interpolate it in the template, but 2　problems arose:

as the number of template grew, the number of method also grew.
the templates can be edited but only information extracted by the method associated with the template can be filled in.

The solution

Use reflection with a dictionary structure to map template fields to entity properties or URL generation methods.

Implementation

Email Template

The email template class stores the templates of the subject of the email and its body separately, but the mapping info for both is stored in one JSON dictionary:

using System.ComponentModel.DataAnnotations;

namespace MyProject.Data.Models
{
    public class EmailTemplate
    {
        [Key]
        public string Id { get; set; }
        [Required]
        public string Subject{ get; set; }
        [Required]
        public string Body{ get; set; }
        [Required]
        public string InterpolationInfo { get; set; }
    }
}

Templates

The "blanks" in the email template are strings enclosed in curly brackets like {EntityId}. To fill in the "blanks", we need to replace them in both the subject and body interpolation strings.

Subject template

[{EntityId}] New information concerning {EntityName} is available!

Body template

Dear {Title} {Username}

To see more information about this entity please go to:

[Entity] {EntityURL}

Sincerely.

-------------------------------------------------

[General] {GeneralURL}

Dedicated Method

This is the way the method associated to the email template was written before the refactoring:

using MailKit.Net.Smtp;
using MimeKit;

public async Task SendSpecificTemplateEmailAsync(string baseUri, EntityType Entity)
{
    using (var client = new SmtpClient())
    {
        try
        {
            EmailTemplate template = _context.EmailTemplates.Where(template => template.Id == "specific-template").First();
            string? Subject = template.Subject;
            string? Body = template.Body;
            if (Subject != null && Body != null)
            {
                if (baseUri.EndsWith("/"))
                {
                     baseUri = baseUri.TrimEnd('/');
                }

                var emailMessage = new MimeMessage();

                AuthenticationState authState = await _authenticationStateProvider.GetAuthenticationStateAsync();
                ClaimsPrincipal authUser = authState.User;
                ApplicationUser user = this._context.Users.Where(user => user.Email == authUser.Identity.Name).First();
                emailMessage.From.Add(new MailboxAddress(user.UserName, user.Email));

                emailMessage.To.Add(new MailboxAddress(Entity.RecipientName, Entity.RecipientEmail));

                Subject= Subject.Replace('{EntityId}', Entity.Id.ToString());
                Subject= Subject.Replace('{EntityName}', Entity.Name);
                emailMessage.Subject = Subject;

                Body = Body.Replace('{Title}', Entity.Title);
                Body = Body.Replace('{Username}', Entity.Username);
                Body = Body.Replace('{EntityURL}', $"{baseUri}entity/{Entity.Id.ToString()}");
                Body = Body.Replace('{GeneralURL}', $"{baseUri}");
                emailMessage.Body = new TextPart(MimeKit.Text.TextFormat.Text) { Text = Body };

                client.Connect(host: _host, port: _port, useSsl: false);
                client.Send(emailMessage);
            }
            else
            {
                throw new ArgumentNullException();
            }
        }
        catch (Exception e)
        {
            System.Diagnostics.Debug.Print(e.ToString());
            throw e;
        }
        finally
        {
            client.Disconnect(true);
            client.Dispose();
        }
    }
}

Mapping Dictionary

The mapping information used for interpolation is stored as a JSON dictionary:

{
  "Subject": {
    "EntityId": "Id",
    "EntityName": "Name",
  },
  "Body": {
    "Title": "Title",
    "Username": "Username",
    "EntityURL": "@GetEntityUrl"
    "GeneralURL": "@GetGeneralUrl"
  }
}

We will parse the JSON data using Newtonsoft.Json's JObject.Parse() and get the interpolation mappings for both subject and body:

using Newtonsoft.Json.Linq;

dynamic jsonDict = JObject.Parse(template.InterpolationInfo);
dynamic subjectDict = jsonDict.Subject;
dynamic bodyDict = jsonDict.Body;

Then we use loop on the (key,value) pairs to extract the string to replace and the value to replace it with:

foreach (JProperty pair in subjectDict)
{
    string placeholder = $"{{{pair.Name.Trim()}}}";
    if (string.IsNullOrEmpty(placeholder))
    {
        throw new ArgumentNullException();
    }
    else
    {
        string propertyName = pair.Value.ToString();
    }
}

Properties

For properties of the entity, reflection is required to retrieve property values using a string. Then a simple call to Replace() on the template string does the trick:

var property = typeof(entityType).GetProperty(propertyName);
var replacement = property.GetValue(Entity).ToString();
Subject = Subject.Replace(placeholder, replacement);

Generated URLs

For generated URLs, I decided to use methods added on my email sending service and to put a @ at the start of method names to differentiate them from the entity properties:

string memberName = propertyName.Substring(1);
var replacement = typeof(EmailService).InvokeMember(memberName, BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.NonPublic, null, this, [baseUri, Entity]).ToString();
Subject = Subject.Replace(placeholder, replacement);

All these URL generating methods need to have the same parameters like below:

private string GetSpecificEntityURL(string baseUri, EntityType Entity)
{
    Uri entityUri;
    bool created = Uri.TryCreate(new Uri(baseUri), $"entity/{Entity.Id.ToString()}", out entityUri);
    if (created == false || entityUri == null)
    {
        throw new Exception("URL NotGenerated");
    }
    return entityUri.AbsoluteUri;
}

Refactored Method

Putting the new method all together:

public async Task SendTemplatedEmailAsync(string templateId, string baseUri, EntityType Entity)
{
    using (var client = new SmtpClient())
    {
        try
        {
            EmailTemplate template = _context.EmailTemplates.Where(template => template.Id == templateId).First();
            string? Subject = template.Subject;
            string? Body = template.Body;
            if (Subject != null && Body != null)
            {
                if (baseUri.EndsWith("/"))
                {
                    baseUri = baseUri.TrimEnd('/');
                }

                var emailMessage = new MimeMessage();
                AuthenticationState authState = await _authenticationStateProvider.GetAuthenticationStateAsync();
                ClaimsPrincipal authUser = authState.User;
                ApplicationUser user = this._context.Users.Where(user => user.Email == authUser.Identity.Name).First();
                emailMessage.From.Add(new MailboxAddress(user.UserName, user.Email));
                emailMessage.To.Add(new MailboxAddress(Entity.Manager, Entity.ManagerEmail));

                dynamic jsonDict = JObject.Parse(template.InterpolationInfo);
                // Subject
                dynamic subjectDict = jsonDict.Subject;
                foreach (JProperty pair in subjectDict)
                {
                    string placeholder = $"{{{pair.Name.Trim()}}}";
                    if (string.IsNullOrEmpty(placeholder))
                    {
                        throw new ArgumentNullException();
                    }
                    else
                    {
                        string propertyName = pair.Value.ToString();
                        if (propertyName.StartsWith('@'))
                        {
                            string memberName = propertyName.Substring(1);
                            var replacement = typeof(EmailService).InvokeMember(memberName, BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.NonPublic, null, this, [baseUri, Entity]).ToString();
                            Subject = Subject.Replace(placeholder, replacement);
                        }
                        else
                        {
                            var property = typeof(EntityType).GetProperty(propertyName);
                            var replacement = property.GetValue(Entity).ToString();
                            Subject = Subject.Replace(placeholder, replacement);
                        }
                    }
                }
                emailMessage.Subject = Subject;

                // Body
                dynamic bodyDict = jsonDict.Body;
                foreach (JProperty pair in bodyDict)
                {
                    string placeholder = $"{{{pair.Name.Trim()}}}";
                    if (string.IsNullOrEmpty(placeholder))
                    {
                        throw new ArgumentNullException();
                    }
                    else
                    {
                        string propertyName = pair.Value.ToString();
                        if (propertyName.StartsWith('@'))
                        {
                            string memberName = propertyName.Substring(1);
                            var replacement = typeof(EmailService).InvokeMember(memberName, BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.NonPublic, null, this, [baseUri, Entity]).ToString();
                            Body = Body.Replace(placeholder, replacement);
                        }
                        else
                        {
                            var property = typeof(EntityType).GetProperty(propertyName);
                            var replacement = property.GetValue(Entity).ToString();
                            Body = Body.Replace(placeholder, replacement);
                        }
                    }
                }
                emailMessage.Body = new TextPart(MimeKit.Text.TextFormat.Text) { Text = Body };

                client.Connect(host: _host, port: _port, useSsl: false);
                client.Send(emailMessage);
            }
            else
            {
                throw new ArgumentNullException();
            }
        }
        catch (Exception e)
        {
            System.Diagnostics.Debug.Print(e.ToString());
            throw e;
        }
        finally
        {
            client.Disconnect(true);
            client.Dispose();
        }
    }
}

The dedicated method can be summed up to one call of our new method:

public async Task SendRequestCreationCompletedEmailAsync(string baseUri, EntityType Entity)
{
    await SendTemplatedEmailAsync("specific-template", baseUri, Entity);
}

Finally, the URL generating methods:

private string GetEntityUrl(string baseUri, EntityType Entity)
{
    Uri entityUri;
    bool created = Uri.TryCreate(new Uri(baseUri), $"entity/{Entity.Id.ToString()}", out entityUri);
    if (created == false || entityUri == null)
    {
        throw new Exception("URL NotGenerated");
    }
    return entityUri.AbsoluteUri;
}
private string GetGeneralUrl(string baseUri, EntityType Entity)
{
    Uri generalUri = new Uri(baseUri);
    return generalUri.AbsoluteUri;
}

DEV Community: Ailete619