DEV Community: Lisi Linhart

How I setup my Mac for coding

Lisi Linhart — Sat, 11 Mar 2023 13:50:00 +0000

This post was originally posted on my blog

As a developer, setting up your machine for coding can be a time-consuming process. However, taking the time to properly configure your tools and environment can greatly improve your productivity and make coding a more enjoyable experience. In this blog post, I'll walk you through the steps I take to set up my macOS machine for coding. So, let's get started!

Installing Applications

First I install my essential applications that will be useful for coding. Here are the applications I use on a daily basis:

Brave: My browser of choice at the moment
VSCode: I love VSCode with some specific extensions
Spotify: Coding is better with some good music to stay focused and productive.
iTerm: I've been using this terminal for years and my favourite feature is the hotkey overlay outside of the IDE.

VSCode extensions

One of the great things about VSCode is the wide range of extensions available that can help you customize your coding environment to suit your needs. Here are a few extensions that I love:

Github CoPilot: Great autocompletion and writing the code you need through comments
GitLens: I love seeing all the Git information I need directly in the editor
Volar: Since I work a lot with Vue these days, I tend to use some helpers specifically for Vue.
Markdown All in One: I write lots of markdown, so these helpers make it easier to type

Installing brew

Homebrew, also known as brew, is a popular package manager for macOS that makes it easy to install and manage software packages. I'll use brew to install several packages that are essential for coding environments.

Here's how to install brew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Installing brew packages

Now that we have brew installed, we can use it to install machine packages. Here are a few packages I recommend installing:

nvm: Node Version Manager (nvm) is a tool that allows you to easily switch between different versions of Node.js. brew install nvm
rbenv: Ruby Version Manager (rbenv) is a tool that allows you to easily switch between different versions of Ruby. brew install rbenv
gh: GitHub CLI (gh) is a command-line interface for GitHub that allows you to perform many GitHub operations from your terminal. brew install gh
zsh: Zsh is an alternative shell to the default bash shell that comes with macOS, it provides additional features and customization options brew install zsh
oh-my-zsh: Oh My Zsh is a popular framework for managing your Zsh configuration. It comes with a variety of plugins, themes, and customization options that can help you be more productive while coding. sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Configuring Oh My Zsh

You can customize your Zsh configuration by editing the .zshrc file, which is located in your home directory: nano ~/.zshrc To enable the oh my zsh plugins, add the following line to your .zshrc file, here are some I use:

plugins=(git alias history)

To create custom aliases, add the following line to your .zshrc file:

alias alias_name='command_to_run'

Conclusion

With essential applications, extensions, and packages like VSCode, Git Lense, Iterm, Brew, NVM, RBenv, GH, and Oh My Zsh, I have everything I need to code in the environment I enjoy. The beauty of a customized development environments is that you can tailor it to your specific needs and preferences. With a little bit of tinkering, you'll be coding like a pro in no time!

Improve your Vue 3 accessiblity with linters & git hooks

Lisi Linhart — Sun, 13 Nov 2022 14:43:42 +0000

💖 Originally published on my blog

In this post, we'll look into adding accessibility linters to your Vue 3 project. This can be your regular Vue 3 app or a Nuxt 3 website or any other environment. Adding accessibility linters can be a great first step to improving the accessibility of your app or website. Of course, you should always learn about different accessibility topics and there is no one size fits all solution, but linters can be a great baseline because they are enforced while you're writing you're code. With git hooks we can ensure that no new code is added, that doesn't follow these linters and it can also be useful for junior developers to learn when they might be doing something wrong. In this post we'll look into adding the following tools & linters:

Creating a new Vue 3 app

First, we'll create a new Vue 3 app. The Vue quickstart makes it very easy to create a new project.

npm init vue@latest

Make sure to directly install the ESLint and Prettier plugins, because they will help us later on.

✔ Add ESLint for code quality? - Yes
✔ Add Prettier for code formatting? - Yes

Now we can directly jump into our new project and it should already show the welcome screen.

cd vue-project
npm install
npm run dev

Adding the ESLint accessibility plugin

The next step is to extend our ESLint setup to include a plugin for a11y. Since we scaffolded our project with ESLint, we should have a .eslintrc.cjs file in our project with some standard plugins installed. Let's take a look at it:

/* eslint-env node */
require('@rushstack/eslint-patch/modern-module-resolution')

module.exports = {
  root: true, // This is required to prevent ESLint from looking for a configuration file in parent folders
  'extends': [
    'plugin:vue/vue3-essential', // vue 3 linting
    'eslint:recommended', // standard eslint javascript linting
    '@vue/eslint-config-typescript', // typescript linting
    '@vue/eslint-config-prettier' // prettier linting
  ],
  parserOptions: {
    ecmaVersion: 'latest' // Allows for the parsing of modern ECMAScript features
  }
}

So let's add the eslint-plugin-vuejs-accessibility plugin to our project. We can do this by running the following command:

npm install --save-dev eslint-plugin-vuejs-accessibility

And then we need to add it to our .eslintrc.cjs file:

module.exports = {
  root: true,
  'plugins': ['vuejs-accessibility'], // add the plugin
  'extends': [
    "plugin:vuejs-accessibility/recommended", // add the recommended rules
    ...
  ],
  parserOptions: { ... }
}

After this, we can run our linter and see if we have any accessibility issues in our project. Since we just scaffolded the project there are probably no issues. We can run the linter with the following command:

npm run lint

Perfect, no issues! Let's add some accessibility issues to our project and see if the linter can catch them. Open your App.vue file and remove the alt attribute from the image tag. The linter should now show an error:

<header>
    <img
        alt="Vue logo" // <--- remove this line
        class="logo"
        src="./assets/logo.svg"
        width="125"
        height="125"
    />

    <div class="wrapper">
        <HelloWorld msg="You did it!" />
    </div>
</header>

When running npm run lint again, we should see the following error:

✖ error  img elements must have an alt prop, either with meaningful text, or an empty string for decorative images  vuejs-accessibility/alt-text

We can see more details for the specific rules in the docs of the different plugin rules like this one: vuejs-accessibility/alt-text

Adapting the linter

It's also possible that you need to activate a specific rule or set options for a rule, because your project has specific needs. You can do this by adding a rules section to your .eslintrc.cjs file:

module.exports = {
  root: true,
  'plugins': ['vuejs-accessibility'],
  'extends': [
    "plugin:vuejs-accessibility/recommended",
    ...
  ],
  'rules': {
    'vuejs-accessibility/alt-text': ['error', { // <--- this would change the options of the rule
      'elements': ['img'], // <--- e.g. only lint images, but no other HTML elements
      'img': [],
      'object': [],
      'area': [],
      'input[type="image"]': []
    }],
    "vuejs-accessibility/no-autofocus": "off", // <--- this would disable this rule
  },
  parserOptions: { ... }
}

Adding stylelint and the stylelint-a11y plugin

Next we also want to lint our CSS, because we can also have accessibility issues there. We can do this by adding the stylelint linter to our project. The configuration there depends on what CSS processing you're using. For this case, we'll use CSS modules:

npm install --save-dev postcss-html stylelint stylelint-config-recommended-vue stylelint-config-standard stylelint-config-prettier  stylelint-config-css-modules @ronilaukkarinen/stylelint-a11y

Let's take a look at these packages:

stylelint - The core linter
stylelint-config-standard - The standard config for stylelint
stylelint-config-prettier - The config to make sure that the stylelint and prettier configs work together
stylelint-config-recommended-vue - The config for linting Vue components
@ronilaukkarinen/stylelint-a11y - The plugin for linting accessibility issues in CSS (this is a fork of the original plugin, but works for stylelint version >= 14)

Adapting the stylelint configuration

After installing the packages, we can create a new .stylelintrc.js file in the root of our project and add the following config:

module.exports = {
  extends: [
    "stylelint-config-standard",
    "stylelint-config-prettier",
    "stylelint-config-recommended-vue",
    "stylelint-config-css-modules",
    "@ronilaukkarinen/stylelint-a11y/recommended",
  ],
};

Let's also add a new script to our package.json file to run the linter. By adding --fix in the end, it would try to autofix the issues:

{
  "scripts": {
     "lint:style": "stylelint 'src/**/*.{vue,css}' --fix" 
  }
}

Now we can run stylelint to see if we have any issues in our CSS:

npm run lint:style

When running npm run lint:styles again, we should already see an error:

✖  Unexpected duplicate selector ":root", first used at line 2  no-duplicate-selectors

The stylelint plugin only activates three rules by default, but we can enable more rules by adapting the .stylelintrc.js file:

module.exports = {
    extends: [
        "stylelint-config-standard",
        "stylelint-config-prettier",
        "stylelint-config-recommended-vue",
        "stylelint-config-css-modules",
        "@ronilaukkarinen/stylelint-a11y/recommended",
    ],
    rules: {
        "a11y/no-text-align-justify": true,
        "a11y/font-size-is-readable": true,
        "a11y/media-prefers-color-scheme": true,
        "a11y/line-height-is-vertical-rhythmed": true,
        "a11y/no-display-none": true,
        "a11y/no-obsolete-element": true,
    },
};

Let's try breaking some of those rules. Open the src/App.vue file and add the following CSS:

.wrapper {
  line-height: 1.3;
  outline: none;
  text-align: justify;
  font-size: 12px;
}

This should trigger some more errors:

✖  Expected a larger font-size in .wrapper               a11y/font-size-is-readable
✖  Expected a vertical rhythmed line-height in .wrapper  a11y/line-height-is-vertical-rhythmed

Adding a pre-commit hook to prevent committing code with accessibility issues

Now that we have a linter that checks our code for accessibility issues, we can add a pre-commit hook to prevent committing code with accessibility issues. We can do this by using the lint-staged package and husky. Let's install these packages:

npm install --save-dev lint-staged husky

Adding lint-staged

We can add a new lint-staged config to our package.json file to run the linters on the staged files:

{
  "lint-staged": {
    "*.{js,ts,vue}": [
      "npm run lint"
    ],
    "*.{css,vue}": [
      "npm run lint:style"
    ]
  }
}

Installing husky

Next we need to run lint-staged whenever we commit files. Husky is a tool that allows us to run scripts at certain git events. We can use it to run a script before we commit our code. The following command will setup husky, modify our package.json and create a sample pre-commit hook that you can edit. By default, it will run npm test when you commit.

git init # if you haven't initialized git yet
npx husky-init && npm install

After running the command, you should see a new .husky folder in the root of your project. In that folder, you'll find a pre-commit file. Let's edit that file and replace npm test with the following:

npx lint-staged

Now you can try commiting some code with accessibility issues and see that the commit fails.

git add .
git commit -m "test"

Lint staged should run the linters and prevent you from committing code with accessibility issues.

✔ Preparing lint-staged...
✔ Hiding unstaged changes to partially staged files...
❯ Running tasks for staged files...
  ❯ package.json — 31 files
    ❯ *.{js,ts,vue} — 14 files
      ✖ npm run lint [KILLED]
    ❯ *.{css,vue} — 11 files
      ✖ npm run lint:style [FAILED]
✔ Applying modifications from tasks...
↓ Skipped because of errors from tasks. [SKIPPED]

Conclusion

In this article, we learned how to add accessibility linting to our Vue 3 project. By adding pre-commit hook we can prevent committing code with obvious accessibility issues. This is a perfect starting point for a new project, where multiple developers are working on the same codebase trying to make it accessible from the beginning. If you want to learn more about accessibility, here are some great resources & tools:

The Junior Developer Journey - Part 7

Lisi Linhart — Tue, 01 Nov 2022 18:49:48 +0000

Working well & avoiding burnout

As we learned in the past few posts, the life of a junior developer is very busy. You’re learning about new technical things, building your profile, and getting better at teamwork at the same time. All this constant need for improvement can feel challenging. So a central part of your journey is also about learning to work well and avoiding burnout. Taking too much on isn't just a problem for senior developers and can hit junior developers just as hard. Let's discuss a few of the harder issues you will face in tech:

Imposter Syndrome

You might have heard of “imposter syndrome.” In the tech industry it's something that's often talked about, but what does it mean exactly? Imposter syndrome is when you feel that you don't deserve the success you have. You feel like you're just pretending to be good at what you do, and that you're going to be found out at any moment. This can manifest itself in different ways:

You see other developers and you start thinking that they all are smarter or more talented than you
You constantly feel that one day somebody will expose you as a fraud and you will be thrown out
You wonder if it's the right career for you because there are so many things in tech which you don’t know yet

There is not a single way to deal with imposter syndrome. It's a very personal thing and you need to find a way that helps you deal with those feelings. But here are some tips to help you:

Talk to other developers about it. You will find that you are not alone in feeling this way
Watch some talks about imposter syndrome
Accept that you will never know everything. There is always something new to learn, and that's a good thing
Don't be afraid to ask for help. You're not a fraud and you're allowed to make mistakes. If you're stuck, there is likely someone who enjoys helping you out

Handling gatekeeping / dismissal

As a junior developer or someone new to the industry, you will most likely experience some kind of dismissal or gatekeeping. One of the most common dismissals you will get is if you don’t have a former computer science degree. But there are also other reasons for being dismissed. Personally, as a woman, I have experienced various forms of “Yes, but women can’t be programmers”. I have also experienced being corrected on anything technical I share. But there are also other reasons for dismissal like race, gender, educational background, or even the choice of programming language. Diversity in tech is still a big issue and a lot of people leave tech, just because of this. There will often be people who will try to discourage you from pursuing a career in their field and will try to make you feel like you don’t belong.

The best way to deal with gatekeeping is to ignore it. If someone makes you feel like you're not supposed to be there, you have two options: confront them about it or set boundaries with that person. Not everyone is willing to admit they might be wrong and you don’t need to prove yourself to anyone if you enjoy a certain field, whether is C++ or CSS. Even if you're learning and don't know everything, inspiring, sharing, and encouraging others is one of the greatest contributions you can make to a technical community.

Knowing when to take a break

For a lot of developers, coding is a passion. That’s great if that’s the case because you get to do a lot of what you like during your work time. But it can also lead to programming too much and not being able to take breaks. Especially if you do a lot of extra events and projects on top of your 9 to 5 job. Between working, writing blog posts, teaching classes, joining hackathons and conferences, working on a side project, and connecting with others, it’s quite easy to get burned out. Here are some signs to look out for:

Constantly think about coding, coding projects, blog post ideas, or other technical things
Loss of excitement about the area you work in
Feeling tired or anxious
Feeling like you can’t keep up with the work you have to do
Feeling like you’re not good enough

Exercise 8 - Avoiding burnout

Let's be honest. Developing and coding is a lot of fun, but it can also be very taxing on your brain. The best thing you can do when you start feeling stressed, anxious or tired, is to give your brain some rest.

Learn to say no

If you have too many opportunities you will need to start to prioritize the things that are important to you. Saying yes to everything will harm you in the long term and will eventually lead to burnout. By putting quality over quantity you will stay sane and will still grow your career in some ways.

Know what you (don’t) want

At the beginning of my career, I started speaking at conferences a lot. But after some time I learned, that I did enjoy speaking, but just at a few selected events a year instead of all the time. A different choice could be that you do want to help others and build something great, but you don't want to work with a certain technology. It can be helpful to write down what you want and what you don’t want in your professional life.

Exercise, eat well, and sleep enough

This is a no-brainer, but it's still worth mentioning. Since so much of a developer's day is spent sitting, it’s important to build physical movement into your day. This can be a walk during lunch, a quick run in the morning, or a workout in the evening. It's also important to take breaks and not work too much. If you're not feeling well, take a day off. You will be more productive in the long run.

Conclusion

Being a junior developer can be really hard. There is so many things to learn, not to do, do more of and in between all of that you can easily burn out. In the past I often had moments, where I felt I wasn't good enough yet. I also had moments, where I doubted whether it was the right career for me (especially as a women) and moments where I was excited by the communities and feedback I got. But in the long term you can only do good work and help others, when you take care of yourself. So take a break, go for a walk, and enjoy the journey.

The Junior Developer Journey - Part 6

Lisi Linhart — Thu, 27 Oct 2022 10:57:32 +0000

This post was originally posted on my blog

Learning in public

In the last post we discovered what we can do to become more visible. A lot of the things mentioned are connected to the "Learning in public" or "Working in public" movement. Learning in public is describing the process of sharing what and how you learn, while you’re actually doing it. This can be done by writing blog posts, speaking at meetups, writing a newsletter or recording online videos. You can read this blog posts that goes even deeper into that topic.

Leveraging social media

After creating something, whether it's a video, an article or a newsletter, we need to find a way to share it with many people as possible. This is where social media comes in play. Not everyone likes to spend their time on social media. However, in terms of developer careers, I noticed that it can be hugely beneficial. I got my current job by announcing that I was looking for a new opportunity on Twitter and various companies reached out to me. Similar things happened to many other developers I know, who are active on social media and got their jobs that way.

Twitter

Twitter is great if you want to keep up-to-date with the latest technology news and gossip. It’s a great platform to directly interact with people in the tech community and bigger brands. If you already have some blog posts or side projects to show, it can be great place to share your current work there.

Reddit has a huge developer community and different subreddits for all kinds of specific topics. If you're learning Javascript, check out the /learnjavascript subbreddit, into datascience, join the /datascience subbreddit, doing rust, go talk to people on the /rust subrredit. Reddit is a great place to find people or communities from a specific technological specialty.

Youtube

Although youtube often is not seen as a social network, you can find a lot of developer communities and learning content there. From LearnCode.academy, Eli the Computer Guy or Derek Banas, there are a lot of successful youtubers out there that share programming knowledge with their communities.

Discord / Slack

If you are interested in some very specific technology or framework, it’s very likely that there will be a discord or slack channel dedicated to just that thing. These chat channels are a great place to get help or just to meet other people doing the same things.

Dev.to

Dev.to is one of the newer platforms, that is also gaining a lot of popularity. Many beginners enjoy it, because it's super easy to start blogging without the need for your own website. You can build a nice personal profile and link your blog posts to specific tags. This makes it easy to find your content and connect with other people having similar interests.

Conclusion

Starting to show your work in public can be intimidating and there will definitely be moments where someone will discourage you or there is no feedback at all. However, if you keep going, you will see that it's a great way to meet new people and get better at what you do. People will start asking you questions and see you as an inspiration for their own work. Just keep trying what works and doesn't work for you and in the long term, you will gain more contacts and opportunities to grow.

Exercise 7 - Learning in public

Find three people, who are highly engaged in the area you currently are learning. Write them down and also write down, what they do that particularly interests you and seems to work.

The Junior Developer Journey - Part 5

Lisi Linhart — Sun, 23 Oct 2022 14:39:05 +0000

This post was originally posted on my blog

Building a public profile

Most junior developers will have some kind of idea of what role they might want to hold in the future or for what kind of company they might want to work. However, before most people can the dream job, they will have to build some kind of credibility. Getting that dream job will very much depend on what impression the employer gets from your interview. If you have some previous experience and work to show, it will increase your chances by a lot. Of course, a lot of developers will get jobs without a portfolio or side projects, but with more visibility, your job opportunities will also multiply. This visibility becomes even more important if you don’t have a computer science degree. People with a degree can get away with not showing so much proof because, with their degree, the expectation will be that they know a lot of the basics.

What that meant for me

For the first internships I got hired for, there were two important things to show: that I had built websites before and that I had some experience in programming, where my bachelors degree was sufficient. Later when I had a few projects and websites to show, I built my profile in a different way. I focused a lot on web animation and coded dozens of free examples on Codepen. I started writing blog posts about that topic and engaged in Slack channels dedicated purely to web animation. After some time I got a lot more oppourtinities in that area: I started writing articles for magazines, I started speaking at conferences and I got client offers to help them out in that area of web animation.

Building a profile

There is not a single right way to build a profile or portfolio. It depends on what you enjoy doing and what you are good at. There is no use in recording youtube videos if you hate standing in front of a camera. However there are some common strategies to show your work and expand your network. Building a network and getting to know your technical community can also be helpful outside of looking for a job because you will get to connect with people who can help you out and might be useful in the future when you want to change jobs or just need help.

Blog Posts

One of the simplest ways to get started in showing what you are working on is to write a blog post about it. The “junior” learning perspective can be super useful for other people who are learning the same topic. You can either set up a simple medium.com or dev.to account to directly blog on those platforms or set up your own blog. By writing about technical topics that interest you, you will improve your writing skills and learn how to transfer your knowledge to other people.

You can read this tutorial to learn more about writing your first blog post:

Meetups

Meetups are great for getting to know people in your area or even finding a mentor. Speaking at meetups can be your start at speaking in public and it can ease the fear of speaking in front of large groups. Before I started speaking at conferences, I spoke at various meetups from my university and local agencies. For many meetups, especially smaller meetups, it’s a struggle to fill all of the speaker slots, so this makes it quite easy to get a slot compared to larger conferences.

Contribute to open source

There are lots of great open-source projects and initiatives like Hacktober, that make it easy to contribute to already existing projects. Small open-source projects (fewer than 10 contributors or 100 stars on GitHub) can be an excellent way to get involved with open-source. The best way is to contribute to a project you find interesting because it will allow you to gain a deeper understanding of how it works. Here are a few ways how you can contribute:

Improve the Readme file and the description of the project itself
Add examples of how the code works and how to use the project
Add translations for a different language
Answer questions in the issue or pull request section of a project
Fix typos or rearrange files to make the project more organized

Many projects will have how to contribute sections, that show what contributions are needed. Make sure to look out for those, to make sure your contributions are useful. You can read the following guides that teach you all about open-source contribution:
https://opensource.guide/

Record a video

Recording videos can also be a great way to share your learning journey, especially if you prefer speaking to writing. I have never created a youtube channel to share my learning journey, but there are various videos of me on youtube from different meetups and conferences that people still watch. The funny thing is that the most watched video of me speaking, was a video that was recorded at a really small local meetup. The talk I gave was about how to do data visualization with python and there were only around 20 people there. But over the years it reached a lot more people through the uploaded video on youtube, who found it very helpful, because it was a basic and short introduction to the topic, that I normally don't have much time to explore.

Here are some ideas on how to get started:

Talk through how you solved a particular problem and recreate your steps as you do so
Demonstrate something you just learned about a programming language, framework, or tool
Record yourself while you work on a side-project

No matter what format you are comfortable with, videos are certainly a great way to share your knowledge!

Starting side projects

Side projects are a great way to move your learning in a direction that you are interested in. In a company, you will often not be able to choose the projects you would want to work on, but by doing side projects, you can learn more about topics that you find fascinating. Side projects are great for showing how much experience you have during a coding interview. It will make clear that you are passionate about learning and can go that extra step of spending some free time to improve your skills. The great thing about side projects is that there is no pressure or deadline. It doesn’t have to be something that makes money or is super useful, but can just be something you enjoy creating.

Here are some great side project ideas I have seen over the years:

One-page layout pages
Geometric Art
Quiz games
Popular service lookalike
Tribute page
Counter or countdown tools
Digital postcards
Online CV
Any kind of generator (Jokes, Words, Names, … )

Exercise 6 - Building a profile

There are many ways to build a profile and expand your network. It’s important to find a way that you enjoy and that you are good at. If you are not sure what you want to do, you can try out different things and see what you like. Here are some questions to ask to find an area that you can do to build a profile upon and expand your network.

Topic	Questions
Blog Posts	What topics do you want to write about? What topics do you enjoy reading about?
Meetups	What meetups are there in your area?
Contribute to open source	What open source projects are there that you can contribute to?
Record a video	What topics do you want to talk about?
Starting side projects	What side projects could be fun to build?

The Junior Developer Journey - Part 4

Lisi Linhart — Sun, 09 Oct 2022 17:08:02 +0000

This post was originally posted on my blog

Climbing the ladder

Once you acquired some of the basic skills you need, to get an entry-level job in the industry, there will be a lot of new challenges waiting for you. As a junior developer on your first job, there are tons of things to learn, from teamwork to taking responsibilities.

In most companies, you will be promoted from junior once you have certain necessary team and soft skills for the employer. You need to transition out of the junior role, where people will take a lot of time to help you and become independently productive. As a regular developer, you will be responsible for the tasks that are assigned to you and are able to estimate and finish those tasks in time.

The difference between a junior and a senior developer

Senior developers are the ones that are very independent and productive. But not only do they have a lot of technical knowledge, but they also learnt a lot of non-technical skills like scoping work, managing teams, adjusting to priorities, helping others and writing proposals.

The main focus of a junior developr is improving technical coding skills, which makes it challening to learn about these other important areas that a senior engineer needs. Nevertheless, we want to look at the whole journey and how to level up as a developer not only from the technical side.

As an experienced engineer, you will be able to take responsibility for entirely new features, identify potential issues in the future and communicate to your team about it. Let's look three things you can do to improve as a junior developer.

Asking questions

When working on new projects and challenges, you will often get stuck or take three times the time a senior developer would take. This is why seeking feedback and asking questions is one of the most important skills you need to learn as a junior. Instead of trying to solve the problem by yourself, which might be too hard for you, you will save a lot of time if you ask a colleague.

Of course, this has to be in an adequate amount, because not all team members will have the whole day to help you out. This is why it’s good to get to know all of your team members and find the people that enjoy mentoring and helping you out. If someone doesn’t enjoy helping other developers, you can’t force them.

Many junior developers have the fear that asking questions might make them seem unskilled, but the reality is that a lot of people enjoy helping out. Even if it’s just taking 5 minutes out of their day, this can help you get unstuck and continue on your task. It also shows that you are willing to learn and acknowledge the experience your more senior colleagues have.

Before you ask a question, you should always try to solve the problem yourself. By asking yourself the following questions first, you'll be able to know if you are stuck and need help:

Have I used a debugger like console logging to help me with this problem?
Have I checked with available sources like StackOverflow?
Have I understood the code to the best of my ability?

If you tried your best and are really just stuck, because the problem goes above your abilities, it’s a good time to ask your colleagues for help. Since you already spent some time on this problem, you can show them exactly where you think things are going wrong and what you tried to fix the problem.

Seeking feedback

Another important aspect is also to review your code and get feedback on your (team) work. Try to find someone that can take a look at your code or pair program with you, to find issues that you might not have noticed. Take lots of notes and find good questions that can help you in your learning. By actively participating and collaborating in your team, you will improve not only your coding skills but also your team and communication skills.

To get the right feedback, it’s essential to learn to ask the right questions and be prepared for honest answers. By asking clear questions, you will get the necessary answers you need to improve. You shouldn’t mistake getting feedback as an opportunity to get praise, but to find areas to improve in. Here are some questions you can ask:

What is something you would like me to stop doing?
What is something you would like me to start doing?
What is something I could do differently that would add value to our team?

Professionalism

As a senior, acting and being professional is a given. Senior developers accept their responsibilities and act that way. They communicate openly, are on time, and don’t make excuses. They try to solve problems with the whole team instead of blaming someone else. They also talk about things that might not have worked out. A professional developer will be honest about the work they and the team have done and see the results as something that was achieved together and not by themselves.

Exercise 5 - Leveling up as a developer

Here are some questions to figure out what non-technical skills you need to improve on in order to become a senior developer.

Topic	Questions
Team Skills	Are you involved in your team and asking questions?
Communicatoin	Are there ways that you can improve your communication?
Time Management	Are you on time? How can you improve your time management?
Responsibility	Do you take responsibility and can also admit when things go wrong?

The Junior Developer Journey - Part 3

Lisi Linhart — Sun, 02 Oct 2022 19:29:17 +0000

This post was originally posted on my blog

Picking the right path

When you start in development, there are endless choices of learning materials, blogs, videos, and courses to take. It can be hard to choose the right learning path, because it’s impossible to learn everything. The key to this challenge is to realise that you can never know everything about all the areas.

A good way to start is to pick one specific thing and stick with it. Don’t learn three frameworks or different programming languages at the same time, choose one and stick with it for a few months, ideally 6 to 12 months before you start learning something else. To gain a deep understanding of a specific programming language or framework you will have to use it continuously for many months. The problem with only trying out something intensely for a week is that you will have forgotten all about it two months later.

There are a lot of roadmaps and learning paths out there and it can be hard to figure out what might be the right path for you. To get to a senior level, you will have to spend many hours practicing this specific thing. That could be building a backend in Node.js, creating user interfaces with CSS, optimizing Postgres databases, or building apps in React or Vue. Whatever it is, stick with it for a few months and you will feel that the daily practice will pay off. If there is a topic that particularly interests you, that will help hypercharge your learning, because it will be easier to create projects and keep learning in an area that you find exciting.

Here is a list of some of the most popular learning paths:

Roadmaps like this can be useful in the beginning, especially if you are learning by yourself. They give you some guidance around what topics you might still need to learn more about.

The Dunning Kruger effect

After a few months of practice, you will gain some confidence. This can be connected to a psychological phenomenon called the Dunning Kruger effect. This effect is a cognitive bias in which people of lower ability mistakenly assess their cognitive ability as greater than it is. In other words, you will feel that you are smarter than you are. This is a dangerous feeling because it can make you overconfident and you will neglect to learn more, practice more and ask for help.

This effect often happens after boot camps or with students after their first year of learning to code. At this point, many developers are very confident in their abilities and they will act like they already know everything there is to know about the area. Once you start to get more insight into a more specialized area, you will realize how wrong you were. You will see how much work is still required to become a master (valley of despair). Once you reach this dip and recognize how much you still have to learn, it’s important not to get discouraged and put yourself down. Becoming an expert takes a long time and a lot of experience (way to enlightenment).

You can make this journey a little bit easier on yourself, by celebrating the small wins with your friends and colleagues. Another great way to get support is to find like-minded people who are also just getting started and help each other out. Depending on the area of your focus, there will often be communities you can join, like specific Slack, Reddit, or Discord channels with people that share their love and knowledge for this topic.

Exercise - Finding out where you are

Having a big goal that you want to reach is essential. Your goal could be that you want to become full-time employed as a software developer, you want to start your own business that makes money or you want to build a project that can do XYZ. These goals are important to know the direction you want to move in, but the essential part is breaking down any large goal down into concrete steps that you can take every day to get there. Here are a few questions, that can help you figure out what your goals and small steps might be:

Topic	Questions
Areas for Improvement	What areas do you want to improve?
Strengths	What are you good in? What do you enjoy doing?
Weaknesses	What do you struggle with currently?
Opportunities	How can you combine your weaknesses with your current role to improve?
Small goals	What is something you can do in one day to improve?
Feedback & Community	Who can you ask for feedback on what you have worked on?
Resources	What resources can you use to improve?

The Junior Developer Journey - Part 2

Lisi Linhart — Fri, 16 Sep 2022 11:44:48 +0000

This post was originally posted on my blog

Foundations for Being a Junior Developer

Being a senior developer in a company mostly means having more responsibilities and deadlines to keep. Seniors have supervision over major projects and need to make sure everything happens on schedule. Now imagine you as a junior developer coming into that new environment, right when the deadline is about to end. The feeling of keeping others from working can be very intimidating and you might think it wouldn’t be right to annoy them with your questions.

You can compare this to being the youngest kid moving to a new neighborhood. All the other kids have lived there for months, years, or even their whole life. They will already know what the quickest way to school is, who the nicest neighbor is and which neighbor to better leave alone. As the youngest kid, you will not only be weaker, but you will need to learn a ton of new information. It will take you a few months to learn all the things the other kids already know, simply from having been there longer. Asking questions can be a shortcut to information that would otherwise take you weeks to find out (for example where to get the best ice cream).

Knowing so much less than all the people in your environment, it’s natural to feel a little insecure. As a junior developer, you will often get stuck and slowly need to learn all the tricks and problems everyone else has already figured out. But there are also a lot of upsides to being a junior. As a junior developer, you will have more freedom and time to work on tasks and are often not forced to be finished in a certain amount of time. This gives you more time to experiment and explore areas that you want to especially improve in.

The kid, who lived in a neighborhood their whole life, is naturally confident in their surroundings. So is the senior developer with years of experience. It helps them solve problems in half or quarter the time it takes you as a junior, but that doesn’t mean you are bad at programming.

One of your main jobs as a junior is simply to get more experienced and gain some confidence. Your projects don’t have to be perfect and finished in the same amount of time it takes seniors to finish them. Stopping to beat yourself up because you don’t know something yet is probably one of the first big lessons as a junior.

Writing bad code

Everyone knows the feeling of writing code that is not perfect. Especially at the beginning of your career, you will write code that is not working as you would expect it to and spend hours debugging certain problems. An important lesson for any developer is to recognize that barely any codebase is perfect. We can improve the process of writing bad code by introducing code linters, commit hooks, and testing into our codebases, but that will not change the amount of experience you have. The tools can help you reduce problems and learn faster, but it’s still very likely that the code you will write in 5 years is going to be better than the code you write today.

Furthermore, clean code is not only about you. The most abstract code piece, might not be the best piece of code because the developers coming after you, will not understand how it works and what it does. As a junior, you also have to recognize that legacy code is a thing and that a lot of the code you write will still be there in 2-5 years and other developers will have to work with it. It also depends on the area in which the code is written. Open Source code should be easy to contribute to, while backend code is often hidden with one person maintaining it, which makes the point of failure very big if that person is gone. In the end, the code you write naturally reflects your knowledge and experience as a developer. Furthermore, there are a lot of great blog posts and books out there about writing more readable code. One of the most popular books to read is Clean Code by Robert. C. Martin, but there are many others, which are also a great introduction to this topic.

How to gain confidence as a developer

To see a path into the future and gain confidence in our skills, it’s essential to recognize all the things you have already accomplished. An easy way to become unhappy is to constantly compare yourself to others who have accomplished or know more than you. By taking some time to recognize the things you have already done, you can train yourself to think more positively. It’s a great feeling to look at code from a year ago and feel like your skills have improved.

Exercise - Confidence

By focusing on what you have already learned, you will see that you're gradually improving and becoming better.

List all achievements in the past 3, 6, and 12 months

Question	Your Answer
What did I achieve in the past 3 months?	E.g. I wrote my first react app
What did I achieve in the past 6 months?	E.g. I completed online course XYZ
What did I achieve in the past 12 months?	E.g. I learnt how to write Javascript

The Junior Developer Journey - Part 1

Lisi Linhart — Sat, 10 Sep 2022 20:35:20 +0000

This post was originally posted on my blog

The reason for this post series

Ever since being promoted to more senior roles, I often get messages from developers just starting in web development & programming. People, who message me, mostly want to know what I did, how I know certain people, and how they can get there. In this post series, I want to share some of my experiences in becoming a senior software engineer. I hope that it will give some of you insight and help you in your journey of becoming a senior engineer and it might inspire you to share what you know on the way.

Getting Started As A Developer

Starting as a junior developer can be challenging. At least I wish I had a mentor that helped me navigate all the different aspects of my early technical career. Additionally, not everyone is lucky enough to find a good mentor to help them out, others might feel uncomfortable with being mentored. However there are many things you can involve yourself in without having a mentor, that will help you learn and grow. In this post series, I will share some of these insights and tips with you.

The interesting part of being a junior developer is that there are so many paths that are open to you. To give you an example: When I started my developer career, I did a 6-month internship in a digital agency in Amsterdam. After six months, they were really happy with me and offered me to stay on as a Frontend Developer, the main work revolved around building websites & digital campaigns, but I decided that I wanted to deepen my knowledge of computer science and higher education. So I applied for a master’s program with a focus on web development. Both ways offered me different outcomes and opportunities. Certainly, I would have also made a great choice with staying at the agency, but asking myself some personal questions about what I wanted, helped me move my career in a direction that aligned closely with my core values.

Where I started

I wrote my first lines of code in 2013 after I switched from a university degree in spatial planning to a degree in media design and informatics. Back then I had never programmed before, although I had a big interest in computers from a young age. Still, I wasn't sure that it would be an area I could excel at. Doing a mixed informatics degree that also had design parts in it, allowed me to commit to the idea of programming. In hindsight, the design part did help a lot later in my career in frontend development, because I was able to learn a lot about the visual design process and have a feeling for things that don't work visually.

Years later at a meetup for women in informatics, I learnt, that these "mixed" degrees like bioinformatics, media informatics or geoinformatics, are often the degrees with higher numbers of women, because women doubt themselves less starting in these applied fields of informatics.

What my biggest challenges were

When I learned to code, the first few years were quite challenging, because I was still figuring out what I wanted to do. In my studies, I focused most of my choice projects on developing web applications. Nevertheless, I also enjoyed all the fields connected to more creative and visual projects and enjoyed the photography and animation classes. I built dozens of projects for university, family, and friends, while also working hard to get better at programming. At that point I was not good enough to have a job as a programmer and worked my summer jobs in completely different fields. The biggest challenge back then was to get more clear on what I wanted to do and what I was good at.

Tip: Ask yourself these questions in the early stages of your career

It takes some time to figure out your ideal work environment. During these first few years, it's important to think about what you like, what you're good at and what you still want to learn. Asking yourself some of these questions will help you to find a job that you will enjoy and that will help you grow:

What are three areas that I know a fair amount about or what do I really want learn more about?
How do I stay updated on current technology trends, news, or products? What motivates me to keep learning?
In what role in a team do I feel most comfortable? Do I enjoy taking on responsibilities for others?
What were the last three projects I worked on? What has excited me most about them?
Who do I admire? What are the things that I think they are doing that are great? How can I also do more of those things?