DEV Community: Richard Wynn

Rubber Duck Debugging in 100 Seconds

Richard Wynn — Tue, 15 Jun 2021 07:53:25 +0000

🦆 What is Rubber Duck Debugging?

Rubber Duck Debugging refers to debugging your code with the aid of a rubber duck. You describe and explain each step of your code, in detail, to the duck, until you notice the problem that's been causing the unexpected behavior.

👤 Origination

The name Rubber Duck Debugging is a reference to a story in the book The Pragmatic Programmer in which a programmer would carry around a rubber duck and debug their code by forcing themselves to explain it, line-by-line, to the duck.

📋 How to apply

The rubber duck debugging method is as follows:

Beg, borrow, steal, buy, fabricate or otherwise obtain a rubber duck (bathtub variety).
Place rubber duck on desk and inform it you are just going to go over some code with it, if that’s all right.
Explain to the duck what your code is supposed to do, and then go into detail and explain your code line by line.
At some point you will tell the duck what you are doing next and then realise that that is not in fact what you are actually doing. The duck will sit there serenely, happy in the knowledge that it has helped you on your way.

(Extracted from rubberduckdebugging.com)

⭐ Why Rubber Duck Debugging?

Help you develop the skill of describing things in simple, clear and concise language.
Engaging in metacognition: Assessing your understanding of a problem, assessing the strategies you've tried and generating new approaches.
Force you to make serious attempts at solving the issue yourself before asking for help.

👴 Quotes

"Insights are often found by simply describing the problem aloud." (Duck, Quack Overflow)

📝 Side Notes

Don't have a rubber duck? Any inanimate object will work equally well.
If you're in a quiet office and don't feel comfortable talking to rubber toys, go out and talk to yourself or writing down your problem can also help.

📰 Others

Be interested? 😃 You can visit the links below read my other posts in your next 400 seconds, too 😊

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

DRY Principle in 100 Seconds

Richard Wynn — Wed, 02 Jun 2021 13:11:24 +0000

💡 What does DRY stand for?

DRY stand for Don't Repeat Yourself, a basic principle of software development aimed at reducing repetition of information.

👤 Origination

The principle has been formulated by Andy Hunt and Dave Thomas in their book The Pragmatic Programmer. It is stated as "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system".

⭐ Why DRY?

Write code once, use it often.
Change code in one place, see the change in all instances.
Less code is good: It saves time and effort, is easy to maintain, and also reduces the chances of bugs.

DRY Violations

Writing/ Copying and pasting the same code or logic again and again.

💡 How to DRY?

Divide your code and logic into smaller reusable units and use that code by calling it where you want.
Put business rules, long expressions, if statements, math formulas, metadata, etc. in only one place.

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

📰 Others

Be interested? 😃 You can visit the links below read my other posts in my programming principles series

Tips To Better Manage Your Time As A Developer

Richard Wynn — Tue, 01 Jun 2021 02:31:55 +0000

Find it hard to manage your time as a developer? These tips will help you better manage your daily time ⏰

📋 Plan Ahead

Planning ahead is a critical part of time management. It's a good idea to plan ahead for the week or at least the day before. Once knowing what needs to be done for the day or week, you'll stay organised and focused.

✔️ Set Tasks/ Goals correctly

Make sure your tasks/ goals are achievable and measurable. Use the SMART method when setting goals. In essence, make sure the goals you set are Specific, Measurable, Attainable, Relevant, and Timely.

👍 Prioritize Wisely

Prioritize tasks based on importance and urgency based on the Eisenhower Matrix. For example, look at your daily tasks and determine which are:

Important and urgent: Do these tasks right away.
Important but not urgent: Decide when to do these tasks.
Urgent but not important: Delegate these tasks if possible.
Not urgent and not important: Set these aside to do later.

☝️ Do One Thing at a Time

Once choosing a task, keep doing it to the end. Working on your project then suddenly checking your email for no reason and writing replies is not only bad time management but also bad for your concentration.

🗑️ Remove Unimportant Tasks/ Activities

It is important to remove excess activities or tasks. Figure out what is significant and what deserves your time. Removing non-essential tasks/ activities frees up more of your time to be spent on important things.

👬 Delegate

To be honest, you can't do everything by yourself, so cut yourself some slack and delegate. Maybe it's time for you to find or train someone to do some simple processes in your work. That frees you up to focus on the bigger projects or the more complicated tasks.

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

Single Responsibility Principle (SRP) in 100 seconds

Richard Wynn — Mon, 31 May 2021 01:20:32 +0000

💡 What does SRP stand for?

The single responsibility principle (SRP) is a programming principle that states that every module, class or function in a computer program should have responsibility over a single part of that program's functionality, and it should encapsulate that part. All of that module, class or function's services should be narrowly aligned with that responsibility.

👤 Origination

The term was introduced by Robert C. Martin (colloquially called Uncle Bob, an American software engineer, instructor, and best-selling author) in an article by the same name as part of his Principles of Object Oriented Design.

💬 Quotes

A class should have one, and only one, reason to change. (Robert C. Martin)

😮 Why SRP?

Functions/ Modules/ Classes that have only one responsibility are much easier to explain, understand, implement and test than a one-for-all one.
Prevents unexpected side-effects of future changes. The more responsibilities your function/ module/ class has, the more often you need to change it.

👃 SRP Violation Smells

One class currently depends on many other classes.
Big classes with lots of methods.
A function that has too many lines of code.
Constantly interfere with other developers on the same function/ module/ class despite working on different functionality.
Top n functions/ modules/ classes that changed most often.

📝 Side Notes

Not oversimplify your code by creating classes with just one function. There is no point in having multiple classes that just contain one function.

💡 Tips

Asking a simple question before you make any changes: What is the responsibility of your function/ module/ class/ etc?
If your answer includes the word and, you're most likely breaking the single responsibility principle. That's the time to take a step back and rethink your current approach to find a better one.

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

📰 Other Programming Principles

Be interested? 😃 You can visit the links below read my other posts in my programming principles series

YAGNI Principle in 100 seconds

Richard Wynn — Sun, 30 May 2021 07:20:45 +0000

💡 What does YAGNI stand for?

YAGNI stands for You Ain’t Gonna Need It. It’s a principle from software development methodology of Extreme Programming (XP). This principle says that you should not create features that it's not really necessary.

This principle is similar to the KISS principle, once that both of them aim for a simpler solution. The difference between them is that YAGNI focus on removing unnecessary functionality and logic, and KISS focus on the complexity.

Why YAGNI?

Any work that's only used for a feature that's needed tomorrow, means losing effort from features that need to be done for the current iteration.
Creeping featurism leads to code bloat; the software will becomes larger and much more complicated.

Quotes

Always implement things when you actually need them, never when you just foresee that you need them. (Ron Jeffries, one of the co-founders of the XP)

📝 When not to practice YAGNI

Learning something new: Evaluate a new technology exclusively to gain the time back later and minimize the risk of losing more time by making the wrong decision.
Current design decisions based on future needs: Don't sabotage your efforts because you think they violate YANGI. Instead, make the future-proof design decision, but only implement enough to fulfill the current need.
Abstracting external dependencies: Take time to astract these dependencies will avoid rework and decrease the complexity.
Testing, Security, Scale, and Business Requirements: YAGNI is not a free-pass on writing tests, secure code, considering scale, or business requirements.

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

📰 Other Programming Principles

Be interested? 😃 You can visit the links below read my other posts in my programming principles series

How to Create a Thumbnail-image-for-post API like dev.to with JavaScript in 100 Seconds

Richard Wynn — Sat, 29 May 2021 06:19:28 +0000

In this article, I will show you step by step to create a thumbnail-image-for-post API like dev.to (just like the image below) by using JavaScript just in 100 seconds ⏰

📂 Repository

You can download the source code of this article on my Github: https://github.com/richard-wynn/dev-to-thumbnail-image-for-post-api
If it helps, don't forget to give my repo a star ⭐

🔧 Necessary Stuffs

NodeJS
uuid: Used to generate a unique id for every created image
express: Fast, unopinionated, minimalist web framework for node
body-parser: Node.js body parsing middleware
moment: Used to format a given date string
puppeteer: Used to get the snapshot of our html content
Postman: Used to test our API

💻 It's Coding Time!

1️⃣ First phase: Create the image-creator module

Create a new folder then run npm init -y inside it to create a package.json file.

Next, run the command below to install our necessary packages:

$ npm install uuid express body-parser moment puppeteer

After that, create a child folder called public (this is the place where the output images will be saved) and update the script attribute inside package.json like this:

...
  "scripts": {
    "start": "node index.js"
  },
...

image-creator.js

Create an image-creator.js file with the following content.

const moment = require('moment');
const { v4 } = require('uuid');
const puppeteer = require('puppeteer');
const fs = require('fs');

const renderHead = () => {
  return `
    <head>
      <style>
        @import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');

        * {
          margin: 0;
          padding: 0;
          box-sizing: border-box;
        }

        body {
          background-color: #606060;
          padding: 82px;
          font-size: 38px;
          font-family: 'Roboto', sans-serif;
          width: 1600px;
        }

        .post-image-wrapper {
          background-color: white;
          border: 2px solid black;
          border-top-left-radius: 24px;
          border-top-right-radius: 24px;
          padding: 32px 42px;
          box-shadow: 12px 12px 0 black;
          margin: 0 auto;
          padding-top: 62px;
        }

        .post-image-title {
          font-size: 3em;
        }

        .post-image-footer {
          display: flex;
          align-items: center;
          justify-content: space-between;
          margin-top: 132px;
        }

        .post-image-footer-left {
          display: flex;
          align-items: center;
        }

        .post-image-avatar {
          width: 64px;
          height: 64px;
          border-radius: 50%;
          border: 3px solid black;
          object-fit: cover;
          padding: 1px;
          margin-right: 10px;
        }

        .post-image-dot {
          margin: 0 12px;
        }

        .post-image-badge {
          width: 64px;
          height: 64px;
          object-fit: cover;
        }

        #js-badge {
          transform: rotate(-2deg);
        }

        #dev-to-badge {
          transform: rotate(8deg);
          margin-left: 3px;
        }
      </style>
    </head>
  `;
};

const renderBody = (post) => {
  const { title, avatar, full_name, creation_time } = post;

  return `
    <body>
      <div class="post-image-wrapper">
        <div class="post-image-header">
          <h1 class="post-image-title">${title}</h1>
        </div>

        <div class="post-image-footer">
          <div class="post-image-footer-left">
            <img src="${avatar}" alt="Avatar" class="post-image-avatar" />
            <span class="post-image-author">${full_name}</span>
            <span class="post-image-dot">•</span>
            <span class="">${moment(creation_time).format('MMMM DD')}</span>
          </div>

          <div class="post-image-footer-right">
            <div class="post-image-badges">
              <img src="https://i.imgur.com/Xe9C9kI.png" alt="JavaScript Badge" class="post-image-badge" id="js-badge" />
              <img src="https://i.imgur.com/OW7qG1B.png" alt="Dev.to Badge" class="post-image-badge" id="dev-to-badge" />
            </div>
          </div>
        </div>
      </div>
    </body>
  `;
};

const getImageHtml = (post) => {
  return `
    <html lang="en">
      ${renderHead()}
      ${renderBody(post)}
    </html>
  `;
};

const createImage = async (post) => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  try {
    const fileName = `${v4()}.png`;

    await page.setContent(getImageHtml(post));

    const content = await page.$('body');
    const imageBuffer = await content.screenshot({ omitBackground: true });

    fs.writeFileSync(`./public/${fileName}`, imageBuffer);

    return fileName;
  } catch (error) {
    return '';
  } finally {
    await browser.close();
  }
};

module.exports = {
  createImage,
};

index.js

Create an index.js file with the following content.

const { createImage } = require('./image-creator');

(async () => {
  const fileName = await createImage({
    title:
      'How to Create a Thumbnail-image-for-post API like dev.to with JavaScript in 100 seconds',
    avatar: 'https://i.imgur.com/bHoLpV6.jpeg',
    full_name: 'Richard Wynn',
    creation_time: '2021-05-29',
  });

  console.log(fileName);
})();

Let run npm start to run the script and hurrayyy, we've got a new image created inside the public folder 😍 😍

2️⃣ Second phase: Create an image-creator API with Express.js

Let update index.js with the following content:

const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
var os = require('os');
const { createImage } = require('./image-creator');
const port = process.env.PORT || 5000;

const app = express();

// Configure body-parser
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());

// Serve static files
app.use('/public', express.static(path.join(__dirname, 'public')));

app.post('/', async (req, res) => {
  try {
    const data = req.body;
    const errors = {};

    if (!data['title'] || data['title'] === '') {
      errors['title'] = 'Title is required!';
    }

    if (!data['avatar'] || data['avatar'] === '') {
      errors['avatar'] = 'Avatar is required!';
    }

    if (!data['full_name'] || data['full_name'] === '') {
      errors['full_name'] = 'Full name is required!';
    }

    if (!data['creation_time'] || data['creation_time'] === '') {
      errors['creation_time'] = 'Creation time is required!';
    }

    if (Object.keys(errors).length > 0) {
      return res.status(500).json({
        status: 'FAILED',
        message: 'Failed to create a thumbnail image for this post!',
        errors,
      });
    }

    const fileName = await createImage(data);

    return res.status(200).json({
      status: 'SUCCESS',
      message: 'Create a thumbnail image successfully!',
      data: `/public/${fileName}`,
    });
  } catch (error) {
    console.log(error);

    return res.status(500).json({
      status: 'FAILED',
      message: 'Failed to create a thumbnail image for this post!',
    });
  }
});

app.listen(port, (err) => {
  if (!err) {
    console.log(`Server is listening on port ${port}...`);
  }
});

Let run npm start to run the script and use Postman to make a request to http://localhost:5000 with the following JSON data:

{
    "title": "How to Create a Thumbnail-image-for-post API like dev.to with JavaScript in 100 seconds",
    "avatar": "https://i.imgur.com/bHoLpV6.jpeg",
    "full_name": "Richard Wynn",
    "creation_time": "2021-05-29"
}

Click Send and boom, we've got a link to the image:

Then make another request to the link to see what we get:

Hurrayyyy, it works like a charm 🎉🎉

This is just a for-fun project of mine. It it helps, don't forget to give my Github repo a star or a like to this post 😉😉

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

KISS Design Principle in 100 seconds

Richard Wynn — Sat, 29 May 2021 00:33:21 +0000

💡 What does KISS stand for?

💋 KISS principle (or Keep It Simple, Stupid) is a design principal which states that most systems work best if they are kept simple rather than made overly complicated. KISS is used in a variety of disciplines, such as interface design, product design, and software development.

👤 Origination

This principle is thought to have been coined by the late Kelly Johnson, who was the lead engineer at the Lockheed Skunk Works (a place responsible for the S-71 Blackbird spy plane amongst many other notable achievements).

Kelly explained the idea to others with a simple story. He told the designers at Lockheed that whatever they made had to be something that could be repaired by a man in a field with some basic mechanic's training and simple tools. The theater of war (for which Lockheed’s products were designed) would not allow for more than that. If their products weren't simple and easy to understand – they would quickly become obsolete in combat conditions and thus worthless.

⭐ Why KISS?

Less code takes less time to write, minimizes the amount of bugs, and is easier to modify and maintain.
The more complex something is, the more ways there are for it to fail, and the more difficult it is to explain to someone else who needs to understand it.
Perfection is reached not when there is nothing left to add, but when there is nothing left to take away.

🔖 Variants

Keep it short and simple
Keep it simple and straightforward

📝 Side Notes

Not to make things so simple that they compromise the functionality of the final design.
Users will live with a little complexity if it enhances their overall experience.

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

📰 Other Programming Principles

Be interested? 😃 You can visit the links below read my other posts in my programming principles series

3 Task Scheduling Packages for Node.js

Richard Wynn — Fri, 28 May 2021 14:15:53 +0000

⏳ Task scheduling allows you to schedule your code to be executed at a scheduled date/ time, at recurring intervals, or once after a specified interval. In Linux, this is often handled by packages like cron. In this article, I will show you top 4 task scheduling packages that emulate cron-like functionality for Node.js apps.

Node Cron

The node-cron module is tiny task scheduler in pure JavaScript for node.js based on GNU crontab. This module allows you to schedule task in node.js using full crontab syntax.

Popularity

1.449.775 Weekly Downloads (Up to the time of this article)

Installation

You can install node-cron by using npm.

$ npm install --save node-cron

Examples

var cron = require('node-cron');

cron.schedule('* * * * *', () => {
  console.log('running a task every minute');
});

Node Schedule

Node Schedule is a flexible cron-like and not-cron-like job scheduler for Node.js. It allows you to schedule jobs (arbitrary functions) for execution at specific dates, with optional recurrence rules. It only uses a single timer at any given time (rather than reevaluating upcoming jobs every second/ minute).

Popularity

1.941.398 Weekly Downloads (Up to the time of this article)

Installation

You can install node-schedule by using npm.

$ npm install node-schedule

Examples

const schedule = require('node-schedule');

const job = schedule.scheduleJob('42 * * * *', function(){
  console.log('The answer to life, the universe, and everything!');
});

Agenda

Agenda is a light-weight job scheduling library for Node.js that offers:

Minimal overhead. Agenda aims to keep its code base small.
Mongo backed persistence layer.
Promises based API.
Scheduling with configurable priority, concurrency, and repeating.
Scheduling via cron or human readable syntax.
Event backed job queue that you can hook into.

Popularity

55.774 Weekly Downloads (Up to the time of this article)

Installation

npm

You can install agenda by using npm.

$ npm install agenda

You will also need a working Mongo database (v3) to point it to.

CJS / Module Imports

For regular javascript code, just use the default entrypoint

const Agenda = require('agenda');

For Typescript, Webpack or other module imports, use agenda/es entrypoint:

import { Agenda } from 'agenda/es';

NOTE:

If you're migrating from @types/agenda you also should change imports to agenda/es.
Instead of import Agenda from 'agenda' use import Agenda from 'agenda/es'.

Examples

const mongoConnectionString = "mongodb://127.0.0.1/agenda";

const agenda = new Agenda({ db: { address: mongoConnectionString } });

// Or override the default collection name:
// const agenda = new Agenda({db: {address: mongoConnectionString, collection: 'jobCollectionName'}});

// or pass additional connection options:
// const agenda = new Agenda({db: {address: mongoConnectionString, collection: 'jobCollectionName', options: {ssl: true}}});

// or pass in an existing mongodb-native MongoClient instance
// const agenda = new Agenda({mongo: myMongoClient});

agenda.define("delete old users", async (job) => {
  await User.remove({ lastLogIn: { $lt: twoDaysAgo } });
});

(async function () {
  // IIFE to give access to async/await
  await agenda.start();

  await agenda.every("3 minutes", "delete old users");

  // Alternatively, you could also do:
  await agenda.every("*/3 * * * *", "delete old users");
})();

agenda.define(
  "send email report",
  { priority: "high", concurrency: 10 },
  async (job) => {
    const { to } = job.attrs.data;
    await emailClient.send({
      to,
      from: "example@example.com",
      subject: "Email Report",
      body: "...",
    });
  }
);

(async function () {
  await agenda.start();
  await agenda.schedule("in 20 minutes", "send email report", {
    to: "admin@example.com",
  });
})();

(async function () {
  const weeklyReport = agenda.create("send email report", {
    to: "example@example.com",
  });
  await agenda.start();
  await weeklyReport.repeatEvery("1 week").save();
})();

👋 And you? Have you ever used any of these packages or another packages to do cron stuff in Node.js? Feel free to put a comment below 😃

📱 Keep in Touch
If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

Create Chrome Desktop Notfications with JavaScript in 100 seconds

Richard Wynn — Fri, 28 May 2021 04:44:17 +0000

In this article, I will show you steps to create a simple Chrome Desktop Notification looked like the image below by using JavaScript just in 100 seconds ⏰ Let's count down!

📂 Repository

You can download the source code of this article on my Github: https://github.com/richard-wynn/simple-chrome-desktop-notifications

🔧 Necessary Stuffs

Visual Studio Code with Live Server extension installed
Google Chrome, of course 😁

💻 It's Coding Time!

index.html

Create an index.html file with the following content.

<html lang="en">
  <head>
    <meta charset="utf-8" />

    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
    <script src="script.js"></script>

    <title>Simple Chrome Desktop Notification</title>
  </head>

  <body>
    <button id="btn-show-notification">Notify Me!</button>
  </body>
</html>

script.js

Next, create a script.js file inside the same folder with the index.html file above:

$(document).ready(function () {
  $(document).on('DOMContentLoaded', function () {
    // Request desktop notifications permission on page load

    if (!Notification) {
      console.log('Desktop notifications are not available in your browser.');
      return;
    }

    if (Notification.permission !== 'granted') {
      Notification.requestPermission();
    }
  });

  function showNotification() {
    if (Notification.permission !== 'granted') {
      Notification.requestPermission();
    } else {
      const options = {
        body: 'Simple Chrome Desktop Notification',
        dir: 'ltr',
        image: 'image.jpg'
      };
      const notification = new Notification('Notification', options);

      notification.onclick = function () {
        window.open('https://www.google.com');
      };
    }
  }

  $('#btn-show-notification').on('click', showNotification);
});

It's Running Time!

In Visual Studio Code, go to View -> Command Palette... and type Live Server: Open with Live Server then press Enter, a new page will be shown:

Click on Notify Me! and hurray, a notification appears:

Just simple as it is 😉 Hope this will help in case you need to use desktop notifications for your website(s).

📱 Keep in Touch

If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn

5 mistakes that every intern should avoid

Richard Wynn — Thu, 27 May 2021 02:04:06 +0000

⏰ Poor Time Management

One of the most common mistakes interns make is managing their time badly. Getting to work late or taking long lunch breaks doesn't sit well with employers. As a professional, you should adhere to the rules and regulations of the office.

You should also learn how to better manage and prioritize your time. If you have multiple tasks, it's your job to prioritize them. If necessary, speak with your mentor or supervisor to determine which are the most time-sensitive ones.

💻 Avoid Trivial Tasks

Another common mistakes many interns make is to underestimate the importance of menial tasks. These can include research, data entry or filing and although they might not seem that important, they are actually a crucial part of running a business.

By doing those kind of work, you'll also gain the respect of your boss, which could lead to more challenging one. But you want to avoid being taken advantage of. Don't hesitate to speak with your employer, mentor or manager beforehand about responsibilities you'll have grounds for requesting some challenging work mixed in with the filing.

💬 Not Asking for Feedbacks

Feedback is the most valuable part of the internship as it helps you enhance your skills and become a better worker. Getting feedback will let you know about your strengths and weaknesses. It will also expose you to your key skills, strong areas, natural talent, and professional inclination.

Unfortunately, a lot of interns overlook this step, expecting managers to deliver feedback only if something critical comes up. Instead, take the first step and ask them to weigh in some of the tasks you're working on.

🏢 Not Learning the Office Culture

Each office has its own culture that make it different than others. Individuality is a good trait but not when it clashes with the corporate culture. Some offices are formal and corporate, while others are laid-back and casual. Oftentimes just observing how employees behave and interact will help you fit in.

📓 Not Keeping in Contact

Many interns lose touch with an organization once they stop interning there. If you happened to enjoy your time during the internship and you want to be a part of it in the future, then it is important to show your interest by keeping in contact with the organization.

Keeping in touch with the organization will keep you in their good books and they will be more than happy to consider you for a suitable job since you are already familiar with the people and environment of the organization.

What about you? Have you made any memorable mistakes during your internship? 😃

📱 Keep in Touch
If you like this article, don't forget to follow and stay in touch with my latest ones in the future by following me via:

Twitter: https://twitter.com/RichardWynn01
Medium: https://richard-wynn.medium.com
Github: https://github.com/richard-wynn