DEV Community: Shelley Benhoff

Getting Started with .NET and Docker Tutorial

Shelley Benhoff — Wed, 18 Dec 2024 18:27:05 +0000

In today’s development landscape, Docker has become an essential tool for containerizing applications. It allows developers to create, deploy, and run applications in isolated environments, ensuring consistency across different stages of development and deployment. In this Getting Started with .NET and Docker Tutorial, I’ll guide you through creating a .NET project in Visual Studio with Docker container support, enabling you to leverage Docker for simplified deployment and scalability.

Installing Docker Desktop

First, you need to download and install Docker Desktop from the Docker website. You can leave all of the default options checked during the installation process. Once it’s downloaded, sign in using your Docker Hub account. If you don’t have an account, you can sign up at hub.docker.com.

Once Docker Desktop is running, right-click on the icon in your system tray and select “Switch to Windows containers.”

If you get an error message saying that you need to enable Windows containers, run the PowerShell script specified in the dialog in a terminal with admin rights and restart your PC. Then, make sure to start Docker Desktop.

Creating a .NET Core Project in Visual Studio

You also need Visual Studio 2022 Community Edition which you can get from visualstudio.microsoft.com.

Open Visual Studio 2022 and click Create a new project in the welcome dialog.

In the Create a new project dialog, search for “.net core web app” and select the ASP.NET Core Web App (Razor Pages) template. Then, click Next.

Name the project AspNetCoreDockerDemo and select the location where you want to create an application. Then, click Next.

In the Additional information dialog, ensure “Configure for HTTPS” is unchecked and the “Enable container support” box is checked. In the Container OS dropdown, select Windows. Then, in the Container Build Type dropdown, select Dockerfile and then click Create.

Reviewing the Dockerfile

In the solution explorer, you should see a Dockerfile. Let’s take a look at this in detail.

# This stage is used when running from VS in fast mode (Default for Debug configuration)
FROM mcr.microsoft.com/dotnet/aspnet:8.0-nanoserver-1809 AS base
WORKDIR /app
EXPOSE 8080

Purpose:
This stage sets up the base runtime environment your application will run on.

Base Image: Uses the ASP.NET Core runtime image (not the SDK), ensuring a minimal, efficient runtime environment.
WORKDIR /app: Sets the working directory inside the container to /app.
EXPOSE 8080: Informs Docker that the container listens on port 8080 at runtime.

# This stage is used to build the service project
FROM mcr.microsoft.com/dotnet/sdk:8.0-nanoserver-1809 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src
COPY ["AspNetCoreDockerDemo/AspNetCoreDockerDemo.csproj", "AspNetCoreDockerDemo/"]
RUN dotnet restore "./AspNetCoreDockerDemo/AspNetCoreDockerDemo.csproj"
COPY . .
WORKDIR "/src/AspNetCoreDockerDemo"
RUN dotnet build "./AspNetCoreDockerDemo.csproj" -c %BUILD_CONFIGURATION% -o /app/build

Purpose:
This stage is responsible for restoring dependencies and compiling your application.

ARG BUILD_CONFIGURATION=Release: Defines a build-time argument to specify the build configuration (defaulting to Release).
WORKDIR /src: Sets the working directory to /src, where your source code will be copied.
COPY [“AspNetCoreDockerDemo/AspNetCoreDockerDemo.csproj”, “AspNetCoreDockerDemo/”]: Copies the project file into the container.
RUN dotnet restore “./AspNetCoreDockerDemo/AspNetCoreDockerDemo.csproj”: Restores all required NuGet packages.
COPY . .: Copies the entire source code into the container (to /src).
WORKDIR “/src/AspNetCoreDockerDemo”: Navigates into the project’s source directory.
RUN dotnet build …: Builds the project in the specified configuration, outputting compiled artifacts to /app/build.

# This stage is used to publish the service project to be copied to the final stage
FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "./AspNetCoreDockerDemo.csproj" -c %BUILD_CONFIGURATION% -o /app/publish /p:UseAppHost=false

Purpose:
This stage publishes the built application into a folder ready for deployment.

ARG BUILD_CONFIGURATION=Release: Reuses the configuration argument to ensure consistent build mode.
RUN dotnet publish … -o /app/publish: Publishes the application, which includes precompiled binaries and all necessary runtime files, into /app/publish. The /p:UseAppHost=false parameter helps reduce the image size by excluding certain host executables on some platforms.

# This stage is used in production or when running from VS in regular mode (Default when not using the Debug configuration)
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "AspNetCoreDockerDemo.dll"]

Purpose:
This is the final image that will actually be run. It uses the smaller runtime image and includes only the essential published files.

WORKDIR /app: Ensures the working directory is /app.
COPY –from=publish /app/publish .: Copies the published output from the publish stage into the final image.
ENTRYPOINT [“dotnet”, “AspNetCoreDockerDemo.dll”]: Specifies the command that runs when the container starts. It launches the ASP.NET Core application using the .dll file compiled and published in previous stages.

Running the .NET Web Application in a Docker Container

Now, let’s run our application. In the top toolbar, click the start button. This will open your browser and you should see the Welcome page!

If you look at Docker Desktop, you will see the container for our application. This is where you can view the container logs and inspect the container to aid in troubleshooting.

With Visual Studio, Docker integration makes it easy to containerize and deploy .NET applications. By following these simple steps, you can create, build, and run a Docker container for your .NET projects, enabling more efficient and consistent development and deployment workflows.

Get Valuable Learning Resources Delivered To Your Inbox Every Wednesday!

You can learn more about this Getting Started with .NET and Docker Tutorial in my Tech Career Newsletter. This newsletter will give you insight into multiple stages of your career so that you can form your career plan, overcome learning blockers, and stay competitive in today’s crowded job market. It includes featured content from authors and influencers in my network to help you navigate your career and learn new skills. Subscribe today at hoffstech.com/newsletter and set yourself up for career success!

Docker Run vs Docker Start

Shelley Benhoff — Wed, 11 Dec 2024 15:15:47 +0000

Docker has revolutionized the way we build, ship, and run applications, offering developers an efficient way to manage containerized environments. Among the numerous Docker commands, docker run and docker start are two of the most commonly used, yet they often cause confusion among beginners. This blog post will clarify the difference between the docker run and docker start commands, provide walkthroughs for their usage, and discuss use cases where each is applicable.

Docker Run Command

The docker run command creates and starts a new container from an image. Think of it as a two-in-one command: it initializes a container (if one doesn’t already exist) and starts it immediately. The syntax is docker run, followed by the options, image name, startup command, and arguments.

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

Some key options you will often encounter include:

-d: Runs the container in detached mode (in the background).
-it: Runs the container interactively with a terminal.
--name: Assigns a custom name to the container.
-p: Maps host and container ports.
-v: Mounts a volume to persist data.

Running a Docker Container

Let’s create a new container to run an Nginx web server. I’m going to use the integrated terminal in Docker Desktop. First, we need to pull the Nginx image using the docker pull command.

docker pull nginx

Next, we will run the container for the nginx image using the docker run command. We will give the container the name my-nginx, then map port 8080 on the Docker host to TCP port 80 in the container. We will run the container in detached mode and then specify the image name.

docker run --name my-nginx -p 8080:80 -d nginx

We can verify that the container is running in Docker Desktop. Clicking the link in the Ports column will open the Nginx start page.

We can stop the container by clicking stop next to the container name. The container will exit but still exist in a “stopped” state.

Docker Start Command

The docker start command is used to restart an existing container that was previously stopped. Unlike docker run, it does not create a new container.

docker start [OPTIONS] CONTAINER

Some options you may encounter frequently include:

-i: Attaches STDIN for interactive mode.
-a: Attaches the container’s output (logs).

Now let’s start our stopped nginx container. You can either click the start button next to the stopped container in Docker Desktop or use the docker start command with the name of the container.

docker start my-nginx

You should see a green bullet indicating that the container is running. Click on the port link and you should see the nginx welcome page.

Differences Between Docker Run vs Docker Start Commands

The key difference between Docker run and start is that Docker run creates and starts a new container whereas Docker start starts an existing stopped container.

Some use cases for the Docker run command include:

First-time setup: Use docker run when creating a container from an image for the first time.
Different configurations: If you need a container with a different setup (e.g., custom ports, environment variables), docker run allows you to configure these at runtime.
Stateless apps: For containers where you don’t need to retain any data, docker run is ideal since it creates a fresh instance every time.

Some use cases for the Docker start command include:

Reusing containers: When you want to resume a container that was previously stopped without losing its state or data.
Preserving logs and files: Stopped containers retain their logs and file systems. Use docker start to pick up where you left off.
Faster startup: Starting an existing container is quicker than creating a new one.

Understanding the difference between docker run vs docker start is crucial for efficient Docker usage. While docker run is the go-to for creating new containers, docker start shines in scenarios where you need to resume work on an existing one. Mastering these commands will help streamline your workflow and improve container management.

Get Valuable Learning Resources Delivered To Your Inbox Every Wednesday!

You can learn more about this topic in my Tech Career Newsletter. This newsletter will give you insight into multiple stages of your career so that you can form your career plan, overcome learning blockers, and stay competitive in today’s crowded job market. It includes featured content from authors and influencers in my network to help you navigate your career and learn new skills. Subscribe today at hoffstech.com/newsletter and set yourself up for career success!

Dealing with Layoffs

Shelley Benhoff — Wed, 04 Dec 2024 16:50:41 +0000

Dealing with layoffs is an unfortunate reality in the tech industry, where shifting market demands, economic pressures, and organizational restructuring can lead to workforce reductions. If you’ve recently been laid off or know someone who has, it’s essential to approach the situation strategically. Here’s how to cope, rebuild, and thrive after a layoff.

Acknowledge Your Emotions

Experiencing a layoff can trigger the five stages of grief—denial, anger, bargaining, depression, and acceptance—each playing a unique role in the emotional process. At first, denial may manifest as disbelief, making it hard to grasp the reality of the situation. Anger can follow, directed at the company, managers, or even the broader economic climate. During bargaining, you might find yourself wishing things could have gone differently, replaying scenarios where the layoff might have been avoided. Depression may settle in as the weight of uncertainty about the future takes hold, but this stage is also a time for self-reflection. Finally, acceptance brings clarity and readiness to move forward, allowing you to channel your energy into rebuilding your career. Recognizing these stages can help you process your emotions constructively and emerge stronger.

It doesn’t help that layoffs tend to happen at the start or during Q4 of the calendar year which is right before the holidays. And, of course, companies tend not to hire during this time and there’s an uptick in available jobs starting in late January. Being unemployed and uncertain about your future during the holidays is hard but you should focus on the good in your life and spend time with family and friends who understand your situation.

Review Your Finances

After a layoff, reviewing your finances is a critical first step to maintaining stability. Start by evaluating your savings, expenses, and any severance or unemployment benefits available. Identify essential expenses and areas to cut costs, such as pausing subscriptions, reducing dining out, or renegotiating bills like insurance or utilities. Simultaneously, consider opportunities to generate passive income. For instance, creating content on platforms like YouTube can be rewarding in terms of sharing knowledge, building a following, and earning ad revenue or sponsorships over time. Additionally, explore selling digital products like e-books, launching a podcast, or offering an online course in your area of expertise. Diversifying income streams not only cushions financial pressures but also opens new avenues for long-term growth.

Evaluate Your Career Goals

A layoff can be a pivotal moment to reevaluate your career goals and align them with your passions and skills. Consider whether you want to stay in your current field or pivot to a new role or industry. Reflect on what aspects of your previous job brought you fulfillment and where you felt limited. This is also a chance to explore emerging trends, such as AI or green technology, and determine if your skills align with these growing sectors. Setting clear, actionable goals can help you focus your job search and steer your career in a more satisfying direction.

Upgrade Your Skills

The tech industry evolves rapidly, and staying competitive often requires continuous learning. Use your downtime to sharpen existing skills or acquire new ones.

Resources:

Online Platforms: Websites like Pluralsight, Udemy, and LinkedIn Learning offer affordable courses in programming, project management, and more.
Certifications: Consider certifications like AWS, Google Cloud, or Scrum Master to boost your resume.
Community Projects: Look out for hackathons or coding meetups (e.g., via Meetup.com) where open-source contributions are often encouraged.

Reconnect with Your Network

Your professional network can be invaluable in helping you find new opportunities. Reach out to former colleagues, mentors, and industry contacts to let them know you’re seeking your next role.

Strategies:

LinkedIn: Update your profile to reflect your most recent achievements and post about your job search (if you feel comfortable doing so).
Meetups and Events: Attend local or virtual industry meetups to expand your connections.
Alumni Networks: Leverage alumni associations or previous employer networks for job leads.

Prepare Your Cover Letter and Resume

A strong cover letter and resume can set you apart in a competitive job market. Tailor your resume to each role by highlighting relevant skills and quantifiable achievements, such as “led a team of 10 developers to deliver a project 20% under budget.” For the cover letter, avoid generic statements and instead demonstrate enthusiasm for the company and role by connecting your experience to their mission and needs. Keep both documents concise, well-formatted, and free of errors to leave a lasting impression on hiring managers. Remember to customize your applications to reflect the unique requirements of each role. A generic resume or cover letter is less likely to stand out.

Explore Alternatives to Full-Time Employment

Consider alternative career paths if traditional full-time roles are not immediately available. Some of your options include:

Freelancing: Platforms like Upwork and Toptal connect tech professionals with project-based work.
Consulting: Offer expertise to smaller companies or startups on a short-term basis.
Entrepreneurship: Use your skills to launch a side hustle or startup idea.

Layoffs, while painful, can serve as a turning point for growth. By approaching the situation with a clear plan and a positive mindset, you can emerge stronger, more skilled, and ready for the next phase of your career.

You can learn more about setting yourself up for success and standing out above the crowd in my book, Lead Developer Career Guide. Learn the skills you need to move through your tech career, with expert advice on mentoring teams, handling clients and project managers, and keeping your head in emergencies. Click here to get your copy from Amazon!

Lead Developer Career Guide – on Amazon!

Shelley Benhoff — Wed, 20 Nov 2024 19:49:51 +0000

I’m thrilled to announce the release of my book, Lead Developer Career Guide, now available on Amazon in both print and Kindle formats! After years of working in tech and supporting developers at every stage of their careers, I wrote this guide to help others achieve the skills and mindset needed to become successful leaders in our industry. Steve Buchanan, author and Principal PM Manager at Microsoft, wrote the foreword. You can check it out on Amazon here: Lead Developer Career Guide.

Why I Wrote Lead Developer Career Guide

As a developer who moved into leadership roles, I realized there was a gap in resources available for guiding developers who wanted to grow their leadership skills and advance their careers. I’ve had countless conversations with developers who feel ready to take on more responsibility but don’t know how to make that transition. This book is the resource I wish I’d had early on, and I’m excited to share the insights I’ve gathered to support you on your journey.

What’s Inside

In Lead Developer Career Guide, I cover all the skills and strategies developers need to become effective leaders, including:

Building a Leadership Mindset: Learn how to think like a leader and take responsibility for your team’s success.
Communication Skills: From feedback to conflict resolution, mastering communication is essential for any developer leader.
Coaching and Mentoring: Discover techniques to support your team’s growth and create a collaborative work environment.
Career Growth Strategies: Practical advice on how to advance your career, set goals, and achieve work-life balance.

Each chapter includes actionable advice, tips, and examples from real-world scenarios that I’ve encountered throughout my career. Whether you’re a developer hoping to take on more leadership responsibilities, or you’re already in a lead role looking to improve your skills, this guide provides a clear roadmap for growth.

Case Studies

This book includes case studies from other authors and influencers in my network. I want to thank them for taking the time to speak with me and review the final product. Contributors include Chloe Condon, Dan Wahlin, Deborah Kurata, Edidiong Asikpo, Gabriela Martinez Sanchez, Jamie Maguire, Maureen Josephine Onyango, Ryan Lewis, Scott Hanselman, and Steve Buchanan.

Who This Book Is For

This book is for developers of all levels who want to excel in leadership roles, from those just beginning their journey to seasoned leaders looking to refine their approach. I also wrote it for anyone passionate about fostering a positive, inclusive work environment where teams can thrive. If you’re eager to elevate your impact and make meaningful contributions to your team, this book is for you.
Join Me on This Journey

Writing Lead Developer Career Guide has been a labor of love, and I’m honored to be able to share it with all of you. I can’t wait to hear your thoughts on the book, and I’m excited to see how it will help developers grow their skills, take on new challenges, and build fulfilling careers in leadership.

Thank you for your support, and I look forward to hearing how Lead Developer Career Guide impacts your career journey!

What is a Container Registry

Shelley Benhoff — Mon, 11 Nov 2024 17:31:29 +0000

What is a container registry? In this article, we’ll dive into what a container registry is, how it differs from a repository, and why both are essential for containerized applications. We’ll also cover how to use public and private repositories on Docker Hub. So, first things first: What exactly is a container registry? The terms registry and repository in Docker are closely related but refer to different things. Here’s a breakdown of each:

Container Registry

A container registry is a service where Docker images are stored and managed. It’s essentially a centralized location that hosts one or more repositories, allowing users to store, share, and distribute Docker images. Think of it as a server or library where images are kept and managed.

Common examples of container registries include:

Docker Hub: A public registry hosted by Docker where users can share images publicly or privately.
Amazon ECR (Elastic Container Registry): A private registry service by AWS.
Google Container Registry: A private registry service by Google Cloud.
Private Registries: Organizations can also set up their own private container registries within their infrastructure, often using open-source tools like Harbor.

Repository

A repository is a specific location within a registry where a particular image, or a set of related images, is stored. Repositories are used to organize images, often by software name or project. For example, you might have a repository for nginx or my-app.

Each repository can contain multiple versions (or tags) of an image. For example, the nginx repository on Docker Hub has tags like latest, 1.19, 1.20, which represent different versions of the nginx image.

Example to Illustrate:

Registry: Docker Hub (the entire platform).
Repository: nginx (a specific project or application within Docker Hub).

When you refer to an image with docker pull nginx:latest, you are:

Accessing the registry (Docker Hub by default unless specified otherwise).
Pulling an image from a specific repository (nginx).
Fetching a specific tag or version (latest).

Docker Hub is the most popular public registry out there, and it’s an excellent resource for anyone working with Docker. Docker Hub hosts official images for many popular applications, libraries, and even complete environments. You’ll find images for popular applications like MySQL, NGINX, Redis, and even the operating systems you may want to use in your containers.

Working with a Public Repository

Let’s jump into some hands-on examples. First, we’ll start with public repositories, which are visible to everyone.

Install Docker Desktop. This is the application you need to run Docker commands and it’s available for Windows, Mac, and Linux.
Go to Docker Hub, and if you don’t have an account, create one—it’s free and only takes a minute.
Once you’re logged in, you can search for any public image you might need. Look up the ‘nginx’ image, a popular web server.
Make sure you’re logged into your Docker Hub account in Docker Desktop so that you can pull and push images to and from your registry (we’ll get into that in a bit).
Switch to your terminal in Docker Desktop. We can pull the nginx image from Docker Hub by running this command:

docker pull nginx

You can verify that the image has been pulled by going to the images tab.

This command pulls the latest ‘nginx’ image from Docker Hub to your local machine. After pulling, you can run it using a simple command like this:

docker run -d -p 8080:80 nginx

And just like that, you’ve started an nginx server on your machine! Now, you can access it at http://localhost:8080. With public images, it’s that easy to start running well-maintained applications. But let’s say you want to store this image in your own public repository.

Go to Docker Hub and on the repositories tab, click create repository. Name the repository nginx and set it to public. Then, click Create. Notice how it shows you the docker command to push to this repository. You just need to have your username in the tag for the image so let’s go ahead and set that up.

Back in the terminal, type the command:

docker tag nginx username/nginx:v1

This will set a tag that is linked to your repository and it includes the version which is a best practice. Now we can push this to our public repository on docker hub by typing:

docker push username/nginx:v1

Once that’s done, you can verify that the image was pushed by going to the repository in Docker Hub.

Working with a Private Repository

Public images are great, but what if you want to store a private image that only you or your team members can access? Docker Hub offers private repositories for this.

On Docker Hub, go to your dashboard and click on ‘Create Repository.’
Give your repository a name, I’ll call this nginx-private, set it to ‘Private,’ and click ‘Create.’
If you were adding team members to this repository, you would do that on the collaborators tab which requires a paid subscription.
Now, let’s tag and push an image from your local environment to this private repository.

Back in the terminal, we’re going to do the same thing we did earlier for the public repository. We’ll tag our image:

docker tag nginx username/nginx-private:v1

Then, we can push this image to our private repository by typing:

docker push sbenhoff/nginx-private:v1

This command works because we are logged into Docker Hub via Docker Desktop. If you’re using a different terminal, you would have to log into your Docker Hub account using the docker login command. And again, once that’s done, you can verify that the image was pushed by going to the repository in Docker Hub.

To pull the private image from Docker Hub on another machine or by a team member, they’ll need Docker Hub credentials and permission to access the repository.

Once logged in, they can pull the image using the standard command format:

docker pull username/nginx-private:v1

After pulling, they can run the image just like any other container. With Docker Hub’s private repositories, you have more control over who can access your sensitive or work-specific images.
Conclusion

So, to summarize:

A container registry, like Docker Hub, stores your Docker images and can be public or private.
Public images on Docker Hub are freely available for everyone, which is fantastic for quick access to popular software.
Private repositories on Docker Hub let you secure images for specific teams or purposes, giving you added privacy and control.

Get Valuable Learning Resources Delivered To Your Inbox Every Wednesday!

Scrum 101: A Beginner's Guide to Agile Project Management

Shelley Benhoff — Mon, 04 Nov 2024 20:15:04 +0000

Scrum is a lightweight methodology that allows teams to deliver valuable results quickly and effectively. It's based on the Agile principles of flexibility, collaboration, and continuous improvement. The Scrum framework consists of a set of practices and roles that work together to deliver high-quality products in a timely manner. The three key roles in Scrum are the Product Owner, the Scrum Master, and the Development Team. Here's a quick Scrum 101 beginners guide to help you get started using the Scrum framework.

Product Owner

The Product Owner is responsible for defining the product vision and ensuring that the team is working on the highest-priority features. They are the voice of the customer and work closely with stakeholders to understand their needs and expectations. The Product Owner creates and maintains the product backlog, which is a list of features that need to be developed. They prioritize the backlog based on the value each feature provides to the customer. Throughout the project, the Product Owner ensures that the team is delivering a product that meets the customer's needs and provides value to the business.

Scrum Master

The Scrum Master is a servant leader who facilitates the Scrum process and ensures that the team follows the Scrum framework. They coach the team on Scrum practices and principles, and help them identify and remove any obstacles that may prevent them from delivering value. The Scrum Master is responsible for facilitating Scrum ceremonies, such as the Daily Scrum, Sprint Review, and Sprint Retrospective. They also ensure that the team is following the Scrum values of commitment, courage, focus, openness, and respect. The Scrum Master helps the team improve their process and performance over time.

Development Team

The Development Team is responsible for building the product and delivering it in iterations called Sprints. The Development Team is self-organizing and cross-functional, meaning that it includes all the skills needed to deliver the product. The team members collaborate closely to build the product and may pair program or work in small groups to complete tasks. The Development Team is responsible for estimating the effort required to complete each feature, selecting items from the backlog to work on during the Sprint, and delivering a potentially shippable product increment at the end of each Sprint. The team is also responsible for continuously improving their process and performance over time.

Benefits of Scrum

One of the main benefits of Scrum is that it allows teams to adapt to changes quickly. For example, let's say you're working on a software development project and the customer requests a new feature. With Scrum, you can easily add the new feature to the backlog and prioritize it based on the customer's needs. The team can then work on the feature in the next Sprint, which typically lasts two to four weeks. This allows the team to deliver value to the customer quickly and respond to changing requirements as needed.

Another benefit of Scrum is that it promotes collaboration and transparency. The Scrum framework includes several ceremonies, such as the Daily Scrum, Sprint Review, and Sprint Retrospective, which allow the team to communicate and collaborate effectively. For example, during the Daily Scrum, the team members discuss what they accomplished the previous day, what they plan to do today, and if there are any obstacles or issues that need to be addressed. This allows the team to stay aligned and identify any issues early on.

Finally, Scrum encourages continuous improvement. During the Sprint Retrospective, the team reflects on the Sprint and identifies what went well, what didn't go well, and what can be improved in the next Sprint. This allows the team to learn from their mistakes and make adjustments as needed.

Scrum is a powerful Agile project management framework that can help teams deliver high-quality products quickly and efficiently. By using Scrum, project managers can promote collaboration, transparency, and continuous improvement within their teams. If you're new to Scrum, consider taking a Scrum Master certification course or working with a Scrum coach to help you get started.

Get Valuable Learning Resources Delivered To Your Inbox Every Wednesday!

You can learn more tips on learning soft skills for devs in my Tech Career Newsletter. This newsletter will give you insight into multiple stages of your career so that you can form your career plan, overcome learning blockers, and stay competitive in today's crowded job market. It includes featured content from authors and influencers in my network to help you navigate your career and learn new skills. Subscribe today and set yourself up for career success!

How To Overcome Imposter Syndrome In The Workplace

Shelley Benhoff — Sat, 17 Jun 2023 15:46:32 +0000

Imposter syndrome can be a common challenge for Junior Developers. It's the feeling that you don't belong, that you're not good enough, and that any day now, someone will find out that you're a fraud. These thoughts can be demotivating and can hold you back from achieving your full potential. However, the good news is that you can learn how to overcome imposter syndrome in the workplace with the right mindset and strategies.

Recognize Your Own Accomplishments

It's important to recognize your accomplishments and celebrate your successes, no matter how small they may seem. Take the time to reflect on what you've achieved so far in your career, whether it's a successful project, a new skill you've learned, or positive feedback from colleagues. Write down your accomplishments and keep them in a place where you can see them regularly, such as a sticky note on your computer screen or a note on your phone. This will help you remember your achievements and boost your confidence.

Embrace Learning Opportunities

It's normal to feel like you don't know everything. But the truth is, no one knows everything, and there's always something new to learn. Embrace learning opportunities, whether it's taking on a challenging project or attending a conference. This will help you grow your skills and knowledge, and it will also help you realize that everyone has something to learn.

Connect With Others

Connecting with others in your field can be a great way to overcome imposter syndrome. Attend meetups, join online forums, or find a mentor who can offer guidance and support. Talking to others about their experiences and challenges can help you realize that you're not alone in your feelings of self-doubt. You may even find that others look up to you for your unique perspective and skills.

Practice Self-Care

Taking care of your physical and mental health is important for overcoming imposter syndrome. Make sure you're getting enough sleep, eating healthy, and taking breaks when you need them. Exercise can also be a great way to relieve stress and improve your mood. Additionally, consider talking to a therapist or counselor if you're struggling with imposter syndrome or other mental health issues.

Reframe Negative Thoughts

When you start to feel like an imposter, try to reframe your thoughts in a more positive light. Instead of thinking, "I don't know what I'm doing," try thinking, "I'm still learning, and that's okay." Instead of focusing on your mistakes, focus on what you've learned from them. Remember that everyone makes mistakes, and they're an opportunity to grow and improve.

Imposter syndrome can be a challenge for Junior Developers, but it can be overcome with the right mindset and strategies. Remember to recognize your accomplishments, embrace learning opportunities, connect with others, practice self-care, and reframe negative thoughts. By doing so, you can boost your confidence and achieve your full potential in the workplace.

Learn More Tips On How To How To Overcome Imposter Syndrome in the Workplace With My Tech Career Newsletter!

Get Valuable Learning Resources Delivered To Your Inbox Every Wednesday!

You can learn more tips on how to overcome imposter syndrome in the workplace for Junior Developers, Senior Developers, Lead Developers, Project Managers, and Tech Leadership in my Tech Career Newsletter. This newsletter will give you insight into multiple stages of your career so that you can form your career plan, overcome learning blockers, and stay competitive in today's crowded job market. It includes featured content from authors and influencers in my network to help you navigate your career and learn new skills. Subscribe today and set yourself up for career success!

How To Create a GitHub Portfolio

Shelley Benhoff — Sat, 10 Jun 2023 18:16:24 +0000

Learning how to create a GitHub portfolio is a great way to showcase your work as a Junior Developer and make it easy for potential employers or collaborators to see what you can do. In this step-by-step guide, we'll walk you through the process of creating a portfolio using GitHub Pages.

Step 1: Create a GitHub account

If you don't already have one, create a GitHub account. This will give you access to all of the tools you need to create your portfolio.

Step 2: Create a new repository

Once you're logged in to GitHub, click on the "+" button in the top-right corner of the screen and select "New repository". Give your repository a name (e.g. "portfolio") and select "Public". Then, click "Create Repository".

Step 3: Enable GitHub Pages

In the Settings tab of your repository, scroll down to the GitHub Pages section and select "Main" branch as the source. This will enable GitHub Pages for your repository and make your portfolio live at "https://[username].github.io/[repository-name]".

Step 4: Clone Your Repository

Next, you need to clone your repository to your local machine. You can do this either by using GitHub Desktop or the command line, whichever you prefer. You can find instructions for this in the code dropdown in your repository and you can clone your repository to any location on your local machine.

Step 5: Create the HTML and CSS for your portfolio

Now it's time to create the HTML and CSS that will make up the pages of your portfolio. You can do this using a code editor like Visual Studio Code, and you can use a framework like Bootstrap to make the process easier. There are also many free templates available to help you get started. Here's a link to the template I'm using.

You can also include screenshots and a brief description of your projects to give visitors an idea of what you've been working on.

Step 5: Optimize for SEO

To optimize your portfolio for search engines, make sure to include keywords in your HTML files, including your skill sets in your title, description, and headings. You can also include meta tags to help search engines understand what your portfolio is about.

Step 7: Share your portfolio

Once you've finished creating your portfolio, push your code to your repository. You can do this using the Source Control panel for VSCode.

If you go back to your repository settings, you should see the url for your website. You can share the link to your portfolio on your social media accounts, on your personal website, or in your email signature.

And that's it! By following these simple steps, you'll have a professional-looking portfolio that showcases your skills and makes it easy for potential employers or collaborators to learn more about you.

Learn More Tips On How To Create a GitHub Portfolio In My Tech Career Newsletter!

How To Run a Docker Container

Shelley Benhoff — Sun, 28 May 2023 19:38:01 +0000

Docker is a powerful tool that allows users to easily deploy and run applications in containers. Containers are lightweight, standalone, and executable packages that contain everything an application needs to run, including code, libraries, dependencies, and runtime. They are isolated from the host system and from other containers, making them a convenient and secure way to package and distribute applications. In this article, we will discuss how to run a Docker container.

To run a docker container, you will need to have Docker installed on your system. If you do not have Docker installed, you can download it from the official Docker website or use a package manager to install it.

Once Docker is installed, you can run a docker container using the docker run command. The docker run command takes the following syntax:

docker run [OPTIONS] IMAGE[:TAG] [COMMAND] [ARG...]

The IMAGE[:TAG] argument specifies the image to use for the container. The TAG is optional and specifies a specific version of the image to use. If no TAG is specified, the latest version of the image will be used.

The COMMAND argument specifies the command to run when the container is started such as executing a startup script. This is optional and can be omitted if the image includes a default command.

The ARG arguments are optional and can be used to pass additional arguments to the command.

Before starting a container, you may want to first search for the image you want to use. You can do this using the docker search command, which searches the Docker Hub registry for images. For example, to search for an Ubuntu image, you can use the following command:

docker search ubuntu

This will return a list of available Ubuntu images, along with their names, descriptions, and tags. You can then use the name and tag of the image you want to use with the docker run command.

Once you have found the image you want to use, you can run a docker container using the docker run command. Here is an example of starting a docker container using the docker run command:

docker run -it ubuntu:20.04 bash

This command will start a new container based on the ubuntu:20.04 image and run the bash command inside the container. If the image is not found locally, it will be pulled from the registry. The -it option specifies that the container should run in interactive mode and allocate a pseudo-TTY. This is especially useful for debugging running containers and viewing logs.

You can use other options with the docker run command to customize the behavior of the container. Some common options include:

-d: Run the container in detached mode. This means that the container will run in the background and the command prompt will return to the host system.

-p: Map a port on the host system to a port inside the container. This allows you to access the application inside the container from the host system.

-v: Mount a volume inside the container. This allows you to persist data across container restarts and share data between the host system and the container.

For example, to run a container in detached mode and map port 8080 on the host system to port 80 inside the container, you can use the following command:

docker run -d -p 8080:80 nginx

This docker command starts a new container based on the nginx image and runs it in detached mode. The -d option specifies that the container should run in the background, while the -p option maps port 8080 on the host system to port 80 inside the container. This allows you to access the web server running inside the container from the host system on port 8080.

If you wanted to specify a bind mount inside the container, you can use the following command:

docker run -d -p 8080:80 -v /app:/foo nginx

When the host directory of a bind-mounted volume doesn’t exist, Docker will automatically create this directory on the host for you. In the example above, Docker will create the /app/ folder before starting your container.

There are many options to consider when you are running Docker containers and in this article, I listed the most common options that you are likely to use often. If you want to learn more options for running Docker containers, you can find the full list here.

What Is a Dockerfile?

Shelley Benhoff — Fri, 12 May 2023 12:00:00 +0000

When you’re getting started with Docker, it is important to understand what is a Dockerfile. You will work with Dockerfiles in every project you work on regardless of the operating system you’re using in your image. If you want to follow along with the demos in this blog post, you will need the food trucks repo from the Docker community repos. You can find it on their GitHub.

A Dockerfile is similar to a batch script that contains all the commands to build a Docker image. The first line states the base image to begin with and then follow the instructions to install required modules, copy files, and deploy the code which results in a working environment. Every Dockerfile must start with the FROM instruction. This tells Docker what base image to use as you build your final image. In this case, we are using the ubuntu standard OS image. You can find images for many different operating systems and development environments for any technology you’re using.

The LABEL instruction adds metadata to an image. A LABEL is a key-value pair. You can add multiple labels to a Dockerfile to include any custom information you want. In this example, we are creating a key named “maintainer” and setting it equal to the text on the right. Labels are visible when you use a docker inspect command to view low-level information on Docker objects which is helpful to keep your projects organized.

LABEL maintainer="Prakhar Srivastav <prakhar@prakhar.me>"

The RUN instruction will execute any commands in a new layer on top of the current image and commit the results. The resulting committed image will be used for the next step in the Dockerfile. All instructions are executed in order so you have to be careful to add your run instructions in the exact order they should be run. In this example, we are installing the required system-wide dependencies for Python and node as these are needed to run the food trucks website.

# install system-wide deps for python and node RUN apt-get -yqq update RUN apt-get -yqq install python3-pip python3-dev curl gnupg RUN curl -sL https://deb.nodesource.com/setup_10.x | bash RUN apt-get install -yq nodejs

The ADD instruction copies new files, directories or remote file URLs from the listed on the left and adds them to the filesystem of the image at the path listed on the right. The destination path is located inside the image that is being built by the Dockerfile.

# copy our application code ADD flask-app /opt/flask-app

Open a terminal and execute the command docker-compose up and then inspect the filesystem of your container to find the destination file path. You can even save this image as a reference to use for later if you want.

To save an image from a running container, get the container id by typing docker ps. Then, run a docker commit command using the container id and then a custom image name and version. That’s it! You can run the docker images command to confirm your new image has been created.

docker commit [container id] [image name]:[image version]

The WORKDIR instruction sets the working directory for any RUN, CMD, ENTRYPOINT, COPY and ADD instructions that follow it in the Dockerfile. In this example, the node package manager commands are run in the working directory that has been defined.

WORKDIR /opt/flask-app RUN npm install RUN npm run build RUN pip3 install -r requirements.txt

The EXPOSE instruction informs Docker that the container listens on the specified network ports at runtime. EXPOSE does not make the ports of the container accessible to the host.

# expose port EXPOSE 5000

And finally, we have the CMD instruction. There can only be one CMD instruction in a Dockerfile. If you list more than one CMD then only the last CMD will take effect. The main purpose of a CMD is to provide defaults for an executing container. In this example, we are running the app script for the website located in the root of the working directory and naming the app python3.

# start app CMD [ "python3", "./app.py" ]

That’s it! Stop your running container by executing the docker-compose down command. Go back to the Dockerfile and uncomment everything using the shortcut Ctrl+k+u. Save your work and execute docker-compose up.

Open a browser and navigate to localhost on port 5000. You should see the foodtrucks website!

Docker Image vs. Container

Shelley Benhoff — Tue, 02 May 2023 22:52:20 +0000

Docker allows developers to quickly spin up any development environment without having to install all of the software and tools necessary on their local machine. This is accomplished using images and containers but what does that mean? Today, I’m going to explain the difference between a docker image vs container.

What is a Docker Image?

An image is a package containing the information needed to create a container. It includes all the dependencies and deployment configurations that are used at container runtime. Images can inherit from multiple base images using layering. We will discuss this topic in depth during this course and you will build base images and work with the builder pattern and multi-stage builds. layers stacked on top of each other to form the container's filesystem. An image does not have state and it never changes.

If you were working in your local development environment, to get started with any project your first step used to be installing everything you need for the project you’re working on such as your SQL server, IIS, search index provider like Solr, etc. This process is error prone and tedious.

Docker images include all of those tools which means that when you start on a new project, the developers on the team would simply pull the docker image! It’s honestly the best thing ever.

What is a Docker Container?

On the other hand, a container is a runtime instance of an image. It has an image, execution environment, and instructions for runtime such as doing a nuget restore and building the solution using MSBuild.

The idea behind Docker is that it defines a standard to ship software. Containers refer to Shipping Containers which define a standard to ship goods globally. Those goods arrive at a dock and a dock worker (also known as docker) is the person who loads and unloads goods from shipping containers. I was working with Docker for over a year before I heard this and I wanted to pass it on! Let’s take a look at this in practice!

How To Pull A Docker Image and Run a Docker Container

I’m going to use the static-site example. You can get this from the docker-curriculum repo using the run command shown here. I use the Docker extension in VSCode to work with Docker images and containers and I highly recommend it.

docker run -d -P --name static-site prakhar1989/static-site

How To Get The Port Number For a Running Docker Container

You will need to get the port for your static site using the docker port command and specifying the static-site container.

docker port static-site

Open a browser and navigate to your localhost and port number.

Using the Docker Extension in VSCode

I like to use VSCode to work with my Docker containers and if you install the extension, you can manage your containers, images, registries, networks, volumes, and contexts. You can expand the images and containers panels to see what you have created! The name of the image and container is the same: prakhar1989/static-site. However, the container can be referenced by the shorter name or tag “static-site”.

You can also view your containers using the command docker ps. This will show you valuable information about your container including the status and ports.

To view all images, use the command docker images.

In summary, a Docker image is a package which includes all the dependencies and deployment configurations that are used at container runtime. A container is the runtime instance of an image.

Top 4 Soft Skills for Engineers

Shelley Benhoff — Mon, 16 Jan 2023 03:26:18 +0000

In the past, the requirements for engineers and developers focused solely on technical skills including development, technical architecture, and DevOps. The tech industry has changed over the years and now more importance is placed on soft skills such as communication and leadership. Engineers must have a combination of both technical skills and soft skills but what soft skills should they focus on? Here are the top 5 soft skills for engineers.

1. Anticipating Needs

People like it when you anticipate their needs. We do not always ask for help because we often don’t know what help to ask for. When you work on a team, you spend a lot of time with your co-workers. You should get to know them as people and notice when they have questions, especially repeat questions. You can create an FAQ document or glossary of terms to answer their question and add additional terms that are related. That way, they will have a central location to find information and this will also reduce the amount of time you spend answering repeat questions!

2. Improving a Process

Even the best companies suffer from outdated processes. It is human nature to avoid change, especially when a process has always worked. However, technology is a rapidly changing industry and processes must change in order to keep up. If you ever see an outdated process such as using obsolete tooling, manually creating reports, or nonexistent documentation, you should speak up and offer alternatives. You should always look for ways to automate processes because that will make everyone’s life easier!

3. Writing Technical Requirements

Technical requirements are incredibly important to help you plan out your approach to development upfront. Writing detailed technical requirements helps productivity as you will not have to remember your approach off the top of your head. This also allows for any developer to switch off tasks so that someone else can pick up the task quickly. Technical requirements should focus on how to build something to the desired result detailed in the business or functional requirements. Writing out technical requirements also helps to mitigate inaccurate estimates as you break each task down into a list of requirements that are more easily estimated.

4. Project Management

As an engineer, you will work on projects and most likely you will work on a project team. Understanding a bit about project management will help you understand where the project manager is coming from and you will be better able to communicate with them and assist in project planning. There are key aspects of project management that you should understand to ensure your own success and the success of the team. You should understand the difference between Waterfall and Agile as these are the top two project management methodologies that you will encounter in the workplace.

Waterfall includes six phases of Project Management: Requirement Gathering, Design, Implementation, Testing (or Quality Assurance), Delivery, and Maintenance. These phases are performed in a strict order with each phase beginning after the end of the previous phase. This project management methodology is not flexible and relies heavily on the accuracy of the discovery phase where the timeline and budget are set.

The Agile project management methodology includes project phases with a short deadline that are worked on concurrently by the team. Agile is iterative and flexible which helps to manage frequently changing priorities by including all stakeholders and taking their feedback into account. Changes in priority can cause a reduction in productivity, especially if the changes come late in the project. Agile encompasses many popular frameworks including Scrum, Kanban, Extreme Programming (XP), and Adaptive Project Framework (APF).

The tech industry has evolved over the years and now places more importance on soft skills such as communication and leadership, in addition to the traditional technical skills for engineers and developers. Engineers should focus on developing soft skills such as anticipating needs, improving processes, writing technical requirements, and understanding project management. By understanding the key aspects of project management and methodologies such as Waterfall and Agile, engineers can better communicate with project managers and assist in project planning, leading to a more successful outcome for the team. With this combination of technical skills and soft skills, engineers will be well-equipped to navigate the ever-changing tech industry.