DEV Community: ebhargro

Getting Promoted as a Self-Taught Developer

ebhargro — Tue, 12 Sep 2023 16:33:51 +0000

Hi friends!

I got promoted recently. A few weeks ago, I spoke to other apprentices and early-career software engineers at a work event and shared some opinions and advice about getting promoted as a self-taught developer. I’m going to summarize what I spoke to my peers about in this blog post for anyone else who might find it valuable. So, here are my 8 recommendations for getting promoted as a self-taught/boot camp-taught developer:

1) Ask for help strategically.

In a perfect world, junior engineers would be able to ask unlimited questions without fear of judgment. However, I’ve seen other self-taught colleagues receive negative feedback for asking too many questions or for not working independently enough. While I disagree with that idea, I was able to protect myself from receiving such feedback by being very particular about when and how I asked for help.

When asking for help, I always make sure I ask very detailed, informed questions that convey the research I’ve done and the thought I’ve put into the problem. I always explained what exact solutions I’ve tried and why they haven’t worked.

Asking informed questions might look like this:

“I’m stuck at [this specific step] and getting [this specific error message]. I’ve tried [this specific solution] and referenced [link to resources (StackOverflow, Slack threads, etc.)]. Could you help me get unblocked?”

On the other hand, asking uninformed questions might look like this:

“Hey I can’t figure out my ticket, can you help?”

While the first way requires more effort, I think that putting in that extra step will only benefit you in the long run. Not only will you understand your problem better, but you’ll also be able to more effectively take advantage of the help offered by having narrowed your problem down. As an extra bonus, you’ll also be sending a message to your peers that you are thorough, independent, and good at communicating specific technical challenges.

2) Become an owner.

Ownership can manifest in many ways. You could own the development of a feature-end-to-end, or try to establish subject-matter expertise in an area and “own” that domain. Ownership is really about being able to attribute a specific contribution to you and you only. Be creative in considering what your team needs and how you can step up to own a piece of that.

3) Prioritize growth and learning.

Edmond Lau in Chapter Two of “The Effective Engineer” (a book I highly recommend) describes this perfectly, saying that engineers should optimize for “experiences where you learn rather than experiences where you effortlessly succeed”. Personally, I think having a couple of easy bugs or quick-fix tasks on your plate is totally fine, especially if development velocity is something your organization cares about.

Each sprint, I’d try to take on at least one ticket where I’d be challenged/learning something new and pair that with a couple of smaller tickets. I think this strategy paid off in allowing me to maintain good velocity while also having strong code complexity, which can be important in proving you’re ready for promotion.

4) Document all of your contributions.

One of my apprenticeship colleagues (shoutout to Pam!) talked about the importance of having a “brag book” and she is one of the reasons why I kept this in mind early on in my job. I not only documented my contributions to projects, but I also kept screenshots of any shoutouts or spot bonuses I’d receive. Here are other things you may not think of that could be included in your brag book:

Links to spike documents and investigations you’ve led
Notes from any office hours or learning opportunities you’ve pursued
Technical debt or tech hygiene tasks you’ve worked on

As time passes it can be hard to remember all of the work you’ve done, so try to update your document somewhat regularly (once monthly was a good cadence for me.)

5) Get buy-in from your manager by expressing your promotion goal early on.

Almost a full year before the promo cycle began, I spoke with my manager (he actually brought it up to me first!) and we mapped out all of the promotion requirements and identified gaps and areas of improvement early on. This allowed me to be strategic in the work I’d be taking on to make sure there wasn’t anything missing when it came time to get promoted.

In my opinion, it’s never too soon to bring this up. Even if your manager doesn’t feel you’re quite ready for promotion, it’s also best you know that information as soon as possible so you can come up with a readiness plan.

6) Seek mentorship from someone who has navigated the promotion process.

I had a senior engineer outside of my immediate scrum team walk me through her experience going through a promo. I also asked her to review my brag book and provide feedback, specifically asking if there was anything she felt was missing from the criteria for the next level.

Reaching out for this mentorship was so helpful because I was lucky enough that my mentor even shared what salary increase and bonus she received when she was promoted from my level so that I could make sure I was getting fair pay. As a Black woman in engineering, equal pay is something extremely important to me. I am thankful to have had her guidance and transparency to help me advocate for myself!

7) Solicit timely feedback from your peers (and make the process as easy for them as possible!)

I’ve had the pleasure of working with a few different product managers and designers, some on very small one-off tasks or tiny features. However, even if I worked with someone in a limited capacity, I’d always request feedback. You can leverage any internal tools that your company may provide access to, or send out an anonymous Google form.

Whatever tool you use, I recommend making this process as simple as possible. Remember your peers are busy, and the less resistance they feel to doing this task for you, the more likely they are to do it quickly! You can make it easy by requesting feedback within a month of working on a project or task with them, so they can easily remember examples. The more specific the feedback, positive or constructive, the more helpful it will be for you. You can also send over a mini version of your list of contributions to any folks giving feedback on you in case they want to reference specific features/tasks. Remember - make it easy on them!

8) Bring visibility to your work.

Doing great work won’t really matter if no one knows about it. Take advantage of opportunities to demo your work to your broader team, talk about your projects and successes with your colleagues, and share your contributions regularly with your manager. Don’t let all your hard work go unnoticed!

These recommendations are all my opinions on things you can do to make promotion more of a no-brainer for whoever will be evaluating you. My overall advice, however, would be this — understand that promotions are decided by people, and people are imperfect. Therefore, try to stack the odds in your favor as much as possible by being over-prepared!

I hope this post was helpful. Please share and leave a comment if anything resonates with you.

Object Oriented Programming w/ JavaScript | “this”, "new" & constructors!

ebhargro — Sun, 01 May 2022 19:36:55 +0000

Hi there, welcome to my first technical blog post! This is the start of a series where I explain concepts related to OOP (Object Oriented Programming) with JavaScript. If you don’t know what any of those words mean, that’s okay, but be sure to read through the next paragraph and check the free resources linked within to get a primer before reading the rest of the post! If you’re familiar already, feel free to skip the next section.

A quick primer

OOP is a programming paradigm, or a way of thinking about programming. In this way of thinking, websites and applications are built around objects.

In JavaScript, objects are variables that act as containers for data. Objects appear as a collection of key:value pairs like this example below:

Check out this resource for more on what OOP is & how it is used: https://www.techtarget.com/searchapparchitecture/definition/object-oriented-programming-OOP

"this"

You may have encountered the word “this” while reading JavaScript code. If you’re like me, you were probably super confused on the word and its meaning. “this” is a relative reference to the object it belongs to. The keyword makes your code more reusable and is very useful to learn!

As someone who loves languages and writing, viewing the technical term “this” in the same way I think about pronouns in English really helped me wrap my mind around it. I’d like to share my comparison just in case it is also helpful to you!

In English, sometimes we say “she” or “it” or “this” to refer to something else. For example, if your parents tell you “clean up this room”, you know exactly what room they’re referring to based on the conversation’s context. If they’re standing in the living room when they say it, this refers to the living room. If they’re standing in your bedroom, this refers to your bedroom. In the same way, “this” in programming can also have different meanings depending on context:

Alone, this refers to something called the “global object.”

To try this out, open your browser’s console and just type in

console.log(this);

You should see that this === window! Window is the global context of your browser.

In a function, this ⇒ global object*.

In an event, this ⇒ the element that received the event*.

*There are some exceptions here! MDN has a great breakdown of how you can derive the meaning of “this” in different scenarios:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this

constructors & the "new" keyword

Constructors are functions that create new objects. They define properties and behaviors that will belong to that object. Think of them as a blueprint! Many real-world objects are created from blueprints. All cars, for example, tend to share a set of common properties and behavior. They have wheels, windows, and the ability to drive.

A constructor for a Cars object would look like this:

What makes constructors cool is the fact that you can use the properties and behaviors defined within them to create multiple “versions” (or in programming terms, “instances) of the same object.

This can be achieved when the new operator is used when calling a constructor. This word tells JavaScript to create a new instance of an object. (By the way, any time an object is created it is instantiated.) The new keyword is important because without it, the this inside the constructor would not point to the newly created object. new tells this what context it should refer to.

Now your new object will have all the properties defined inside of your constructor, yay!

using parameters for more flexibility:

You can allow your constructor to accept parameters to more easily change its properties to different values.

Let’s say we have a constructor function called Programmer, which takes in two arguments “name” and “language” and has three properties defined:

With parameters, you can make your objects more flexible!

I hope this blog post has helped clarify this, constructors, and the “new” keyword for you! This is my first time attempting to explain a technical concept, so I welcome all some feedback. Let me know what you think by sharing this post on Twitter! If you’d like me to make this a series where I cover some of the key principles of OOP, let me know. I’d love to write more about the prototype chain & inheritance specifically if it would be valuable.
To read more of my blogs, check out my website Code Newbie Chronicles!

Thanks so much for reading!

Ebony

(Disclaimer: this post is not a comprehensive technical explanation of these concepts. As I learn more, I’ll be sure to re-visit this post and correct any inaccuracies!)

Another free resource on OOP:

https://javascriptissexy.com/oop-in-javascript-what-you-need-to-know/#:~:text=JavaScript Prototype,languages and Functions in JavaScript.