This real-world problem underscored the importance of understanding CSS specificity, not just in theory but in practical, day-to-day web development. In this article, I aim to demystify CSS specificity, drawing on this experience to show how a deeper understanding of this concept can save time and frustration in your web development journey.

The Basics of CSS Specificity

Specificity in CSS is like a game where different selectors earn different points. The selector with the highest points wins and its styles get applied. Here’s a quick rundown of the points system:

• Element selectors (e.g., div, h1): 1 point

• Class selectors (e.g., .container, .header): 10 points

• ID selectors (e.g., #navbar, #footer): 100 points

• Inline styles (e.g., style="font-size:12px"): 1000 points

Example:

div { /* 1 point */ }
.header { /* 10 points */ }
#navbar { /* 100 points */ }

Calculating Specificity

When selectors are combined, their points add up. The one with the highest total wins.

Example:

#navbar .menu-item { /* 100 (ID) + 10 (Class) = 110 points */ }
body #content .article h2 { /* 1 (Element) + 100 (ID) + 10 (Class) + 1 (Element) = 112 points */ }

In the examples above, the second selector has higher specificity, so its styles will override those of the first selector if they target the same element.

Practical Tips and Best Practices

• Avoid Overusing ID Selectors: IDs are great for JavaScript hooks or unique styling, but they can make your CSS hard to override due to their high specificity.

• Leverage Classes: Classes strike a good balance between specificity and reusability. They are your best friend for most styling tasks.

• Use !important Sparingly: This declaration overrides any other declarations, regardless of their specificity. Overuse can lead to maintenance nightmares. Use it only as a last resort.

CSS specificity might seem complex at first, but once you understand the basics, it becomes a powerful tool in your web development arsenal. Experiment with different selectors, and you'll soon get a feel for how specificity shapes your stylesheets.

Further Reading/Resources

• MDN Web Docs on Specificity

• CSS Tricks: Specifics on CSS Specificity

Transitioning from javax to jakarta namespaces is pivotal in the Java EE ecosystem, especially when maintaining or lacking control over javax libraries. The transformer-maven-plugin facilitates this migration. In this article, we'll generate a javax library from an XSD file, build a jar, and then create its jakarta version within a Maven project comprising two modules: one for javax, the other for jakarta.

Prerequisites

In this article, we'll be utilizing Java and Apache Maven. It's assumed that you have basic familiarity with these technologies. Additionally, we will employ the transformer-maven-plugin to aid in the migration process. Now, with the basics covered, let's proceed to set up our Maven project for migrating a javax library to a jakarta one.

Creating the Maven Project and Javax Module

1. Create a New Maven Project

    mvn archetype:generate -DgroupId=com.example -DartifactId=javax-to-jakarta -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   

2. Convert to a Multi-module Project

   Edit the pom.xml in the javax-to-jakarta directory to include the pom packaging type and Java 8 source/target:

    <packaging>pom</packaging>
    <properties>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
    </properties>
   

3. Create a Module for Javax

    mvn archetype:generate -DgroupId=com.example -DartifactId=javax-module -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   

4. Generate Javax Library from XSD

   Create a directory src/main/xsd within javax-module, and place the following person.xsd file in it:

    <?xml version="1.0" encoding="UTF-8" ?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
      <xs:element name="Person" type="PersonType"/>
      <xs:complexType name="PersonType">
        <xs:sequence>
          <xs:element name="FirstName" type="xs:string"/>
          <xs:element name="LastName" type="xs:string"/>
          <xs:element name="Age" type="xs:integer"/>
        </xs:sequence>
      </xs:complexType>
    </xs:schema>
   

   Update javax-module/pom.xml to include the jaxb2-maven-plugin and javax dependencies:

    <dependencies>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.1</version>
        </dependency>
    </dependencies>
    <build>
      <plugins>
        <plugin>
          <groupId>org.codehaus.mojo</groupId>
          <artifactId>jaxb2-maven-plugin</artifactId>
          <version>2.5.0</version>
          <executions>
            <execution>
              <goals>
                <goal>xjc</goal>
              </goals>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </build>
   

5. Build and Package the Javax Library

    mvn package
   

Setting up the Jakarta Module

1. Create a Module for Jakarta

    mvn archetype:generate -DgroupId=com.example -DartifactId=jakarta-module -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   

2. Update Parent POM

   Add jakarta-module to the parent pom.xml:

    <modules>
        <module>javax-module</module>
        <module>jakarta-module</module>
    </modules>
   

3. Configure Transformer-Maven-Plugin in Jakarta Module

   Navigate to the jakarta-module directory and edit its pom.xml to include the transformer-maven-plugin and specify the dependency on the javax module:

    <dependencies>
        <dependency>
            <groupId>jakarta.xml.bind</groupId>
            <artifactId>jakarta.xml.bind-api</artifactId>
            <version>3.0.1</version>
        </dependency>
    </dependencies>
    <build>
            <plugins>
                <plugin>
                    <groupId>org.eclipse.transformer</groupId>
                    <artifactId>transformer-maven-plugin</artifactId>
                    <version>0.5.0</version>
                    <extensions>true</extensions>
                    <configuration>
                        <rules>
                            <jakartaDefaults>true</jakartaDefaults>
                        </rules>
                    </configuration>
                    <executions>
                        <execution>
                            <id>default-jar</id>
                            <goals>
                                <goal>jar</goal>
                            </goals>
                            <configuration>
                                <artifact>
                                    <groupId>com.example</groupId>
                                    <artifactId>javax-module</artifactId>
                                    <version>${project.version}</version>
                                </artifact>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
   

4. Execute the Migration

   From the root project directory (javax-to-jakarta), execute the following command to perform the migration:

    mvn clean package
   

Conclusion

In this article, we walked through a structured approach to migrate a javax library to a jakarta library using the transformer-maven-plugin within a Maven multi-module project. This methodology proves to be beneficial especially when there's a need to maintain a javax library or when control over the javax library is not available. Our setup delineated clear, easy-to-follow steps for migration, which is not only reproducible but also sets a foundation for testing and validation, ensuring the integrity of the libraries across the transition.

The transformer-maven-plugin offers a range of features beyond what was explored in this guide, making it a robust tool worth exploring for similar migration projects.

The complete code for the project discussed is available on GitHub, providing a practical reference to jump-start your migration endeavors from javax to jakarta.

JUnit is an essential framework in the Java world for unit testing. You might already be familiar with writing test cases, assertions, and handling expected exceptions in JUnit. However, there is a powerful feature that you might be missing: Parameterized Tests. In this article, we will delve into how you can use Parameterized Tests in JUnit 5 to make your test cases more concise and maintainable.

What are Parameterized Tests?

Parameterized tests are a feature that allows you to execute the same test case multiple times but with different input values. This can save you time and keep your codebase cleaner by reducing the number of explicitly written test cases. Instead of writing separate test methods for each set of input data, you can write a single test and provide multiple sets of inputs. This not only makes your test code more concise but also helps in easy maintenance as the code evolves.

Benefits

• Code Reusability: Avoid redundancy in test cases by reusing the same test method with different data sets.

• Scalability: Easily add more test cases by just adding new sets of data.

• Readability: Improves readability by structuring the input data neatly.

• Maintainability: Makes maintaining tests easier, especially when test logic is complex.

How It Works

In a parameterized test, you define the test method just once. However, instead of hardcoding the input values within the test method, you define them separately and annotate the test method to indicate that it should be run multiple times with different input values. JUnit 5 provides several annotations to define these input values.

Example

Let’s say you have a utility method for calculating the area of a rectangle and you want to test this method. Instead of writing multiple test cases, you can use a parameterized test.

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import java.util.stream.Stream;
import org.junit.jupiter.params.provider.Arguments;

class AreaCalculatorTest {

    @ParameterizedTest
    @MethodSource("rectangleAreaProvider")
    void testRectangleArea(int length, int width, int expectedArea) {
        assertEquals(expectedArea, calculateRectangleArea(length, width));
    }

    private static Stream<Arguments> rectangleAreaProvider() {
        return Stream.of(
            Arguments.of(1, 2, 2),
            Arguments.of(3, 4, 12),
            Arguments.of(5, 6, 30)
        );
    }

    private int calculateRectangleArea(int length, int width) {
        return length * width;
    }
}

In this example, testRectangleArea is the test method that will be executed multiple times. The @ParameterizedTest annotation indicates that this is a parameterized test. The @MethodSource annotation points to the method rectangleAreaProvider, which provides different sets of input values. Each set of values (length, width, and expectedArea) is used as input to the testRectangleArea method in different executions.

Parameterized tests can be used for a wide range of scenarios, from simple input validation to complex algorithm testing. By utilizing them in your test suite, you can make your testing process more efficient and effective.

Setting Up JUnit 5

To harness the power of Parameterized Tests in JUnit 5, you first need to ensure that your project is set up to use JUnit 5. Here is a detailed guide for setting up JUnit 5 in your Java project.

Prerequisites

• JDK 8 or later

• A build tool such as Maven or Gradle (optional, but recommended)

Adding Dependencies with Maven

If you are using Maven as your build tool, add the following dependency to your pom.xml file. Note that JUnit 5 is part of the JUnit Jupiter project, and you should use the junit-jupiter artifact:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.3</version>
    <scope>test</scope>
</dependency>

Adding Dependencies with Gradle

If you are using Gradle, add the following dependency to your build.gradle file:

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'
}

Configuring Maven Surefire Plugin

If you are using Maven, it's important to ensure that you're using a version of the Surefire plugin that supports JUnit 5. Add the following plugin configuration to your pom.xml file:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.1.2</version>
        </plugin>
    </plugins>
</build>

IDE Support

Modern IDEs like IntelliJ IDEA, Eclipse, and NetBeans have built-in support for JUnit 5. However, ensure that your IDE is up to date, as older versions may not support JUnit 5.

Writing a Basic JUnit 5 Test

Before diving into Parameterized Tests, let's write a basic JUnit 5 test to make sure everything is set up correctly. Create a class CalculatorTest with the following code:

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class CalculatorTest {

    private final Calculator calculator = new Calculator();

    @Test
    void testAddition() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3));
    }

    private static class Calculator {
        int add(int a, int b) {
            return a + b;
        }
    }
}

This is a simple test class with a single test case to check the addition method of a Calculator class.

Running the Test

Run the test case through your IDE, or, if you are using Maven, run the following command in the terminal:

mvn test

If you're using Gradle, you can run:

./gradlew test

If everything is set up correctly, the test should execute successfully.

Now that your project is set up to use JUnit 5, you are ready to dive into writing Parameterized Tests as covered in the subsequent sections of this article.

Writing Your First Parameterized Test

Now that you have JUnit 5 set up, let’s dive deeper into writing your first parameterized test. For this example, let's consider you have a simple utility class that provides functionality to calculate the sum of two numbers.

Step 1: Write the parameterized test

Create a new test class named CalculatorTest. Use the @ParameterizedTest annotation to indicate that this is a parameterized test. For this example, let's use the @CsvSource annotation to provide comma-separated values. Each line in @CsvSource represents a set of input parameters followed by the expected output.

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class CalculatorTest {

    private final Calculator calculator = new Calculator();

    @Test
    void testAddition() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3));
    }

    @ParameterizedTest
    @CsvSource({
            "1, 1, 2",
            "2, 3, 5",
            "100, 200, 300"
    })
    void testAddition(int a, int b, int expectedResult) {
        assertEquals(expectedResult, calculator.add(a, b));
    }

    private static class Calculator {
        int add(int a, int b) {
            return a + b;
        }
    }
}

In the above example, the testAddition method is annotated with @ParameterizedTest to signify it's a parameterized test. The @CsvSource annotation provides three sets of data. Each set contains two input numbers and the expected sum. The testAddition method is executed three times with different sets of data.

Step 3: Run the Test

You can run this test in the same way you run regular JUnit tests. If you're using an IDE, you can usually right-click the test class and select 'Run'. If you're using Maven or Gradle, it will also recognize and run your parameterized test as part of the test phase.

Step 4: Understand the Output

When the test runs, JUnit will execute the testAddition method multiple times with different parameters. If the output matches the expected result, the test passes. If any of the executions fail (meaning the output didn't match the expected result), then the parameterized test fails.

Step 5: Analyze and Refactor

After running the tests, if you encounter any failures, it’s essential to analyze the test and the code under test. Determine whether the failure is due to incorrect input data or an issue with the implementation. If needed, update the implementation or correct the test data and re-run the tests.

Parameterized tests are an invaluable tool for increasing coverage with various inputs without the need to write a new test case for each input scenario. This keeps your test suite concise and maintainable. As you get more comfortable with parameterized tests, you can explore more advanced features like custom argument sources and converters.

Formatting the Display Name of Parameterized Tests

In JUnit 5, you can customize the display name of parameterized tests to include the parameters used in each invocation. This is particularly useful for better understanding which values are being tested, especially when looking at test reports. To achieve this, you use the name attribute of the @ParameterizedTest annotation.

The name attribute allows you to specify a pattern for the display name. You can use {index} as a placeholder for the current test invocation index (1-based), and {arguments} to include a list of the actual parameter values. Additionally, you can reference individual method parameter values using {0}, {1}, etc., based on their position.

Here's an example that demonstrates how to format the display name using the name attribute:

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class MathTest {

    @ParameterizedTest(name = "Test #{index}: {0} + {1} = {2}")
    @CsvSource({"2, 3, 5", "4, 5, 9", "10, 20, 30"})
    void testSum(int a, int b, int expectedSum) {
        assertEquals(expectedSum, a + b);
    }
}

In this example, the display name of each test invocation will be something like "Test #1: 2 + 3 = 5", "Test #2: 4 + 5 = 9", and so on. This makes it easier to understand what values are being used in each test case just by looking at the display name.

Different Sources of Parameters

JUnit 5 offers a variety of sources for parameters that can be used in parameterized tests. In this section, we will look at each type of source and provide examples for each of them.

1. ValueSource

@ValueSource allows you to specify a single set of literal values (e.g., integers, strings) that will be used as arguments for the parameterized test.

Example:

import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

class NumberTest {

    @ParameterizedTest
    @ValueSource(ints = {2, 4, 8, 16, 32})
    void testNumberIsPowerOfTwo(int number) {
        assertTrue(isPowerOfTwo(number));
    }

    private boolean isPowerOfTwo(int number) {
        return (number & (number - 1)) == 0;
    }
}

2. EnumSource

@EnumSource allows you to use enum constants as the source of parameters. Additionally, it provides an attribute named mode that lets you control how the enum constants are used in the test. The EnumSource.Mode enum includes several options such as INCLUDE, EXCLUDE, MATCH_ALL, and MATCH_ANY.

Example Enum Class:

import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;

class DaysTest {

    enum Days {
        MONDAY,
        TUESDAY,
        WEDNESDAY,
        THURSDAY,
        FRIDAY,
        SATURDAY,
        SUNDAY
    }

    @ParameterizedTest
    @EnumSource(Days.class)
    void testDaysEnum(Days days) {
        assertNotNull(days);
    }
}

Example with INCLUDE Mode:

javaCopy codeimport static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;

class DaysTest {

    @ParameterizedTest
    @EnumSource(value = Days.class, mode = EnumSource.Mode.INCLUDE, names = {"MONDAY", "FRIDAY"})
    void testIncludeMode(Days day) {
        assertNotNull(day);
    }
}

Example with EXCLUDE Mode:

javaCopy codeimport static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;

class DaysTest {

    @ParameterizedTest
    @EnumSource(value = Days.class, mode = EnumSource.Mode.EXCLUDE, names = {"SATURDAY", "SUNDAY"})
    void testExcludeMode(Days day) {
        assertNotNull(day);
    }
}

Example with MATCH_ALL Mode:

javaCopy codeimport static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;

class DaysTest {

    @ParameterizedTest
    @EnumSource(value = Days.class, mode = EnumSource.Mode.MATCH_ALL, names = {"^.*DAY$", "^MON.*"})
    void testMatchAllMode(Days day) {
        assertNotNull(day);
    }
}

Example with MATCH_ANY Mode:

javaCopy codeimport static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;

class DaysTest {

    @ParameterizedTest
    @EnumSource(value = Days.class, mode = EnumSource.Mode.MATCH_ANY, names = {"^TUES.*", "^FRI.*"})
    void testMatchAnyMode(Days day) {
        assertNotNull(day);
    }
}

3. CsvSource

As we saw earlier, @CsvSource allows you to define sets of values as comma-separated strings. Each string represents the parameters for one invocation of the parameterized test.

Example:

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class MathTest {

    @ParameterizedTest
    @CsvSource({"2, 3, 5", "4, 5, 9", "10, 20, 30"})
    void testSum(int a, int b, int expectedSum) {
        assertEquals(expectedSum, a + b);
    }
}

The @CsvSource annotation in JUnit 5 allows you to provide comma-separated values (CSV) as the source of parameters for a parameterized test. In addition to just specifying the values, @CsvSource offers a few more attributes that give you greater control over how the values are interpreted and passed to the test method. These attributes are:

• value: This is where you provide the sets of values as an array of strings. Each string represents the parameters for one invocation of the parameterized test. The values within each string are comma-separated by default.

• delimiter: Allows you to specify a custom delimiter character that separates values within each string. The default delimiter is a comma (,).

• delimiterString: Similar to delimiter, but allows you to specify a delimiter as a string (it can be more than one character).

• emptyValue: Allows you to specify a custom string that represents an empty value (defaults to "").

• nullValues: Allows you to specify one or more strings that should be interpreted as null.

• textBlock: Allows attribute allows you to specify the CSV values as a text block, which is ideal for multiline content.

Let's look at examples that demonstrate the use of these attributes.

Using a Custom Delimiter

@ParameterizedTest
@CsvSource(value = {"2 : 3 : 5", "4 : 5 : 9"}, delimiter = ':')
void testSumWithCustomDelimiter(int a, int b, int expectedSum) {
    assertEquals(expectedSum, a + b);
}

Using a Custom Delimiter String

@ParameterizedTest
@CsvSource(value = {"2 || 3 || 5", "4 || 5 || 9"}, delimiterString = "||")
void testSumWithCustomDelimiterString(int a, int b, int expectedSum) {
    assertEquals(expectedSum, a + b);
}

Representing Empty Values

@ParameterizedTest
@CsvSource(value = {"'', Smith"}, emptyValue = "Unknown")
void testName(String firstName, String lastName) {
    Assertions.assertEquals("Unknown", firstName);
}

Representing Null Values

@ParameterizedTest
@CsvSource(value = {"NULL, Smith"}, nullValues = "NULL")
void testNameWithNulls(String firstName, String lastName) {
    Assertions.assertNull(firstName);
}

Using textBlock Attribute

The textBlock attribute allows you to specify the CSV values as a text block, which is ideal for multiline content. This greatly enhances readability, especially when dealing with several sets of parameters. Text blocks in Java are delimited by triple double-quotes """, and they preserve the line breaks and spacing within the block.

Here's an example using the textBlock attribute:

javaCopy codeimport static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class MathTest {

    @ParameterizedTest
    @CsvSource(textBlock = """
        2, 3, 5
        4, 5, 9
        10, 20, 30
    """)
    void testSumTextBlock(int a, int b, int expectedSum) {
        assertEquals(expectedSum, a + b);
    }
}

Using useHeadersInDisplayName with textBlock

JUnit 5.8 also introduced the useHeadersInDisplayName attribute, which, when set to true, uses the headers specified in the CSV content as placeholders in the display name of the parameterized test.

Here is an example that combines textBlock and useHeadersInDisplayName:

javaCopy codeimport static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class MathTest {

    @ParameterizedTest
    @CsvSource(textBlock = """
        a, b, sum
        2, 3, 5
        4, 5, 9
        10, 20, 30
    """, useHeadersInDisplayName = true)
    void testSumTextBlockWithHeaders(int a, int b, int expectedSum) {
        assertEquals(expectedSum, a + b);
    }
}

In this example, the first line of the text block contains headers (a, b, sum), and the useHeadersInDisplayName attribute is set to true. This means that the display name of the test will use these headers as placeholders for the values.

Using these attributes, you can customize how the parameters are parsed and passed to your test methods with @CsvSource. This gives you the flexibility to accommodate different data formats and testing scenarios.

4. MethodSource

@MethodSource allows you to refer to methods in the test class that provide the parameters. The method must return a Stream, Iterable, Iterator, or array of arguments.

Example:

import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

class OddNumberTest {

    @ParameterizedTest
    @MethodSource("provideOdds")
    void testIsOdd(int number) {
        assertTrue(isOdd(number));
    }

    private static Stream<Integer> provideOdds() {
        return Stream.of(1, 2, 3, 5, 7, 9, 11);
    }

    private boolean isOdd(int number) {
        return number % 2 != 0;
    }
}

5. ArgumentsSource

@ArgumentsSource allows you to create reusable and more complex parameter sources by defining a custom class that generates the arguments. This is especially useful when working with complex objects and scenarios.

To use @ArgumentsSource, you must create a class that implements the ArgumentsProvider interface. This interface mandates implementing the provideArguments method, which should return a Stream<? extends Arguments>.

Let's take an example where we have a Person class, and we want to test whether the full name of the person is being correctly constructed.

First, let's define the Person class:
Person.java

public static class Person {
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFullName() {
        return firstName + " " + lastName;
    }

    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                '}';
    }
}

Now, let's create an ArgumentsProvider that provides different instances of the Person class along with their expected full names:

PersonArgumentsProvider.java

import java.util.stream.Stream;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;

public static class PersonArgumentsProvider implements ArgumentsProvider {

    @Override
    public Stream<? extends Arguments> provideArguments(ExtensionContext extensionContext) {
        return Stream.of(
            Arguments.of(new Person("John", "Doe"), "John Doe"),
            Arguments.of(new Person("Jane", "Doe"), "Jane Doe"),
            Arguments.of(new Person("James", "Bond"), "James Bond")
        );
    }
}

Finally, let's write a parameterized test that uses the @ArgumentsSource annotation and specifies the PersonArgumentsProvider as the source of arguments:

PersonTest.java

javaCopy codeimport static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ArgumentsSource;

public class PersonTest {

    @ParameterizedTest
    @ArgumentsSource(PersonArgumentsProvider.class)
    public void testFullName(Person person, String expectedFullName) {
        assertEquals(expectedFullName, person.getFullName());
    }
}

In this example, the PersonArgumentsProvider class implements ArgumentsProvider and supplies a stream of arguments where each argument consists of a Person object and the expected full name. The testFullName method in the PersonTest class is annotated with @ArgumentsSource and uses PersonArgumentsProvider as the source of arguments. This approach allows for very flexible and reusable parameter sources for your tests.

6. CsvFileSource

@CsvFileSource allows you to read parameters from a CSV file. This is useful when you have a large set of parameters.

Example:

First, create a file named input.csv in the src/test/resources folder with the following content:

2,3,5
4,5,9
10,20,30

Now, write the test class:

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvFileSource;

class MathTest {

    @ParameterizedTest
    @CsvFileSource(resources = "/input.csv")
    void testSumFromCsvFile(int a, int b, int expectedSum) {
        assertEquals(expectedSum, a + b);
    }
}

Each of these sources for parameters has its use cases, and by using them effectively, you can make your test suite more powerful and maintainable. Choose the one that best fits the requirement of your parameterized test.

Conclusion

Parameterized testing is a powerful feature in JUnit 5 that allows you to execute the same test multiple times with different sets of input values. Throughout this article, we delved into the essentials of parameterized tests and explored the various sources of parameters including @ValueSource, @EnumSource, @CsvSource, @MethodSource, and @ArgumentsSource. We also took a closer look at some advanced features like formatting display names, using text blocks for multiline CSV data, and creating custom argument providers with complex objects.

Embracing parameterized tests can significantly improve the quality of your test suite by ensuring that your code is validated against a wide range of input. It also helps in keeping your test cases DRY (Don't Repeat Yourself) and enhances readability.

As you continue to write tests for your Java applications, consider employing parameterized tests for scenarios where you need to validate the behavior of a method or functionality against various input combinations. This will not only bolster the robustness of your tests but also provide a more comprehensive assessment of your code's reliability.

For further reading and to dive deeper into other features, you can visit the official JUnit 5 documentation.

As a final note, the complete code examples discussed in this article are available on GitHub. Feel free to clone the repository, experiment with the examples, and create your parameterized tests. You can also contribute by suggesting improvements or sharing your examples.

Access the GitHub Repository

Contributions and feedback are always welcome! This repository is intended to be a collaborative space for sharing knowledge and best practices for JUnit 5 and parameterized testing.

Remember that good tests are just as crucial as good code. By leveraging the capabilities of JUnit 5’s parameterized tests, you’re taking a significant stride in producing quality software.

Happy testing! 🚀

Conducting a post-process analysis is a critical and concluding aspect of your personal skill development journey. This phase requires reflecting on your journey, gathering feedback from your inner self, and making note of the lessons learned. It helps in refining your approach and ensures that your future skill development endeavors are even more efficient and targeted.

The process is not merely about looking at what was achieved but delving into how each step of the process contributed to that achievement. Did you find some steps more useful than others? Were you able to effectively address the Dunning-Kruger effect and Impostor Syndrome? Let’s find out.

Revisiting the Steps:

As a reminder, here are the steps from the series:

1. The Power of SMART Goals

2. Break Goals into Achievable Steps

3. Mastering Milestone Evaluations

4. Keep Progress on Track with Regular Check-Ins

5. Keeping Development Plans Agile and Effective

6. Reflection and Tackling Impostor Syndrome

7. The Power of Positivity: Building Your Feedback Repository

8. Assessing and Celebrating Success

Reflect on each step in the skill development series. Were there steps you found particularly helpful? Did any steps feel redundant or not applicable to your journey? Did you find any steps challenging? This reflection helps to tailor the process to your unique learning style and goals.

Personalizing and Adapting the Process:

Remember that the steps provided in this series are a guide, and it’s crucial to adapt and tailor them to fit your journey. You might find that additional steps are necessary for your particular situation, or that some steps can be combined or skipped. The key is to make this process your own.

Don’t hesitate to refine or redefine the steps based on your experiences. You may want to add more detailed steps, or maybe integrate other methodologies that you find effective. Continuously iterate on the process as you learn more about what works for you and what doesn’t.

One of the strengths of this process is its flexibility. By personalizing it, you not only make it more effective for your development but also become more invested in and committed to your learning journey. Embrace the concept of growth and continuous improvement, not just in your skills but also in the process itself.

Analyze Dunning-Kruger Effect and Impostor Syndrome:

Evaluate how well the steps assisted you in addressing the Dunning-Kruger effect and Impostor Syndrome. Reflect on whether the insights and strategies shared in the series were effective in mitigating these psychological phenomena.

Reflect on Your Achievements and Challenges:

Take a moment to reflect on the milestones you achieved, the challenges you overcame, and the knowledge you gained throughout your journey. Were you able to achieve your SMART goals? Did you face any unexpected challenges?

Also, analyze how well you tackled the Dunning-Kruger effect and Impostor Syndrome. Did the process help you gain a better understanding of your skills and capabilities? How did you cope with any self-doubt or overconfidence that emerged along the way?

Document Your Reflections and Insights:

Documenting your reflections, insights, and feedback about the process is incredibly valuable. It serves as a repository of knowledge that you can refer back to, and can also guide you in improving your process for future skill development.

Create a personal journal, a digital document, or a video log – choose the medium that you are most comfortable with. This is also a great way to track your evolution and see how much progress you have made over time.

Plan for Continuous Improvement:

Based on your reflections and insights, create a plan for continuous improvement. Determine which aspects of the skill development process can be refined or which new strategies can be implemented.

Set a timeline for reassessing your progress and adjusting your skill development process. Remember that learning and personal development is a lifelong journey. Continuously striving for improvement ensures that you are always growing.

Exercise: Compare Two Skill Development Journeys

As a personal exercise, think about two skills you have tried to develop - one using the process outlined in this series and one without. Compare the two experiences in terms of ease, effectiveness, challenges faced, and success achieved.

For example, if you worked on improving your public speaking skills using the process and learned a new language without it, compare how the structured approach impacted your journey in each case.

Conclusion:

Having come this far in your skill development journey, it’s vital to recognize the importance of post-process analysis as a step toward ongoing growth. Your journey doesn’t end here; it’s a continuous path of learning and adaptation.

Consider the steps provided in this series as a foundation upon which you can build your personalized skill development process. Encourage yourself to remain committed, adaptable, and ever-evolving. Here’s to your success in all your future endeavors!

The final assessment and celebration aren't merely the end of the skill development cycle; they're a bridge to continuous learning and improvement. This crucial phase is a platform to recognize and appreciate the growth individuals have made through their journey, providing much-needed reinforcement for continuous learning. When grappling with the Dunning-Kruger effect and Impostor Syndrome, individuals often overlook their progress. Having a final assessment and celebration helps to bring this progress into focus and serves as a powerful confidence booster.

Moreover, this process isn't just about the individual's growth. It also serves as an essential feedback mechanism for the trainers and mentors. It helps them understand what worked, what didn't, and how they can improve the learning process in future iterations.

Conducting a Final Assessment

The final assessment provides a holistic view of the individual's progress throughout the skill development cycle. This evaluation should cover whether the set goals were achieved, which milestones were completed, and the individual's progression on the Dunning-Kruger chart.

In cases where the individual has experienced Impostor Syndrome, it's essential to assess how they dealt with it and what strategies helped them overcome it. The objective is not just to measure growth but to understand the journey, the hurdles, and the strategies that led to that growth.

Gathering Feedback

Feedback isn't merely a tool for assessment; it's a key to growth. Gathering feedback from various sources - peers, mentors, and other stakeholders - provides a multi-dimensional view of the individual's progress. It uncovers blind spots that may have been missed in self-assessment and provides validation that aids in overcoming Impostor Syndrome.

Moreover, gathering feedback creates an environment of open communication and shared learning, where everyone involved in the process can learn from each other's insights and experiences.

Reflecting on the Journey

Reflection is a powerful tool for self-growth. It allows individuals to look back at their journey, acknowledging their struggles, understanding their victories, and recognizing their growth. Reflection should involve looking at the specific instances where they experienced the Dunning-Kruger effect or Impostor Syndrome.

Understanding these instances, the feelings associated with them, and how they navigated through them, builds resilience and equips them with tools to handle similar situations in the future.

Celebrating Achievements

Celebration is not just about marking the completion of the skill development cycle. It's about recognizing the effort, dedication, and hard work that went into achieving the goals. This recognition is a vital source of motivation, particularly for individuals who might be grappling with Impostor Syndrome.

A celebration marks their genuine achievements, affirming their abilities, and boosting their confidence. Whether it's a simple congratulatory message, a small ceremony, or a team gathering, celebrating achievements uplifts the spirit and inspires continuous effort.

Encouraging Sharing of Experiences

Sharing experiences provides a platform for mutual learning. As individuals share their journeys, the challenges they faced, the strategies they used, and how they handled the Dunning-Kruger effect or Impostor Syndrome, everyone in the team or community learns from these experiences.

Creating a safe, encouraging space for sharing experiences can enhance the learning culture within a team or organization, fostering collective growth.

Providing Constructive Feedback for Future Development

While the focus is on celebrating achievements, it's equally important to identify areas for further development. Constructive feedback helps individuals understand their strengths and the areas they need to work on.

This feedback, when given thoughtfully and positively, is a springboard for continuous learning, ensuring that the end of one skill development cycle is the beginning of another.

Documenting the Final Assessment

Documentation is key to learning. Keeping a record of the final assessment, feedback, and reflections is not just a reference material; it's a repository of learning. This documentation can serve as a roadmap for future skill development cycles, guiding the setting of new goals and milestones.

Furthermore, documentation allows individuals to periodically review their progress, keeping their growth in focus, and serving as a source of motivation in times of self-doubt.

Setting New Goals for Continuous Learning

As one chapter ends, another begins. Encouraging individuals to set new goals for their next development cycle emphasizes the importance of continuous learning. Setting new goals, particularly based on the feedback and reflections from the previous cycle, ensures that learning is ongoing, dynamic, and responsive to the individual's growth and needs.

For a personal task, reflect on a skill you have been working on recently. Create a document or presentation that will serve as your final assessment for this skill development cycle. Here’s a guide on what to include:

1. Goals and Milestones: Begin by listing the goals you had set at the start of your skill development cycle. Beside each goal, note whether or not you achieved it.

2. Feedback: Write down feedback that you have received from peers, mentors, or other stakeholders. Reflect on how this feedback impacted your progress and what changes you implemented based on it.

3. Challenges Faced: Enumerate the challenges you faced. Include any instances where you felt the Dunning-Kruger effect or Impostor Syndrome impacting your self-perception. Explain how you addressed these challenges.

4. Achievements and Growth: Highlight your achievements and how you have grown through this cycle. Use specific examples or data to demonstrate this growth.

5. Reflection: Take some time to reflect deeply on your journey. What were the turning points? What did you learn about yourself? How do you feel about your achievements?

6. Setting New Goals: Lastly, based on your reflection and any feedback, set new goals for your next skill development cycle. Ensure these are SMART goals and align with your long-term objectives.

Once your document or presentation is complete, consider sharing it with a mentor, friend, or family member and celebrate your achievements together. Use their feedback for additional insights and motivation for your next cycle.

Example

Let's take the example of developing presentation skills over the last few months. Your final assessment document might look something like this:

1. Goals and Milestones: You aimed to deliver five presentations with confidence, receive positive feedback, and reduce reliance on notes during delivery. You achieved all these goals, delivering six presentations, receiving encouraging feedback from colleagues, and steadily decreasing your reliance on notes.

2. Feedback: Your mentor provided feedback after your third presentation, suggesting you try to engage more with your audience. Based on this, you included questions and interactive elements in your next presentations, which were received positively.

3. Challenges Faced: In your second presentation, you experienced a case of Impostor Syndrome, doubting your expertise on the topic. You addressed this by discussing your feelings with your mentor, reviewing your feedback repository, and realizing you had all the necessary knowledge.

4. Achievements and Growth: You started with shaky first presentations, but by the sixth, you were confident, engaging, and note-free. You saw positive remarks in your feedback and felt more comfortable each time you presented.

5. Reflection: You realized that your fear of public speaking was affecting your initial presentations. However, by pushing through and focusing on feedback, you improved significantly. You learned that your perceived lack of ability was more a reflection of your fear than your actual skills.

6. Setting New Goals: For your next skill development cycle, you aim to hone your storytelling in presentations. You want to make your delivery more impactful by creating narratives that can hold your audience's attention and make complex ideas more digestible.

Tips

• Make the final assessment a safe space, free from judgment.

• Use different feedback-gathering tools, such as surveys or face-to-face discussions.

• Encourage honest reflection by sharing your own experiences as a mentor or trainer.

• Tailor the form of celebration to what resonates most with the individual or team.

• Use documentation tools that are easily accessible and retrievable.

Resources

1. Drive: The Surprising Truth About What Motivates Us by Daniel H. Pink.

2. Celebration and The Power of Acknowledgment by Judith W. Umlas.

3. Mindset: The New Psychology of Success by Carol S. Dweck.

Conclusion

Concluding the skill development cycle with a final assessment and celebration is a pivotal juncture that solidifies the value of continuous learning and development. It's an amalgamation of recognition, reflection, and reinvention. It’s not just about celebrating what has been achieved but setting the stage for what can be achieved. As we embrace this culture of celebration and continuous learning, we foster not just individual growth but a community of learners, where experiences and insights are shared, and everyone grows together.

In the next article, we will delve into Post-Process Analysis, where we'll understand the importance of collecting feedback on the entire process and analyze what worked well and what can be improved for future iterations.

A feedback repository is a personalized collection of positive feedback, achievements, and accolades. When Impostor Syndrome clouds one's judgment or self-doubt creeps in, this repository becomes a guiding light. In the face of Impostor Syndrome, where an individual doubts their achievements, this repository provides objective evidence of their competencies, thwarting the Dunning-Kruger effect which causes underestimation or overestimation of one's abilities.

In the modern professional landscape, personal development is continuous. A feedback repository helps in cataloging the milestones achieved, skills acquired, and positive feedback. This reservoir of achievements becomes particularly essential when facing career challenges, ensuring that your self-perception remains rooted in reality.

Select a Format for the Repository:

Selecting the right format ensures that the repository remains functional and inspiring. Whether you prefer a digital document, a mobile app, or an old-fashioned journal, ensure it reflects your personality. Digital tools like Evernote, Notion, and Trello offer added advantages such as tagging, easy search, and cloud storage.

Tips:

• Keep it simple and easy to update.

• Dedicate a fixed time each week for updating.

• Include visual elements such as images or awards.

• Add a few lines reflecting on what each achievement meant to you.

Encourage Regular Updates:

Consistency is key. Regular updates turn your feedback repository into a living document that evolves with your professional growth. Documenting both small and large wins create a broader picture of your achievements over time. It's a reminder of how you rose to various challenges and succeeded.

Include Evidence:

Including tangible evidence such as certificates, screenshots of positive messages, or images of completed projects, adds weight to your repository. This can be particularly compelling when battling Impostor Syndrome, as a tangible proof is difficult for the doubting mind to deny.

Use During Reflection Sessions:

Reflection sessions with your feedback repository allow you to evaluate your growth trajectory and reassess your goals. The repository offers concrete evidence of how far you've come, which is invaluable for setting future targets.

Consult in Times of Doubt:

Your feedback repository should be your first line of defense against self-doubt and Impostor Syndrome. By objectively showcasing your achievements, it negates any internal narrative that undermines your self-worth.

Share with Mentors or Peers (Optional):

Sharing your repository with a mentor or trusted peer allows for external validation and perspectives. This can be immensely empowering and also transform your repository into a shared source of inspiration.

Reflect on Growth:

Consider your feedback repository as a tapestry, where each thread is an achievement that contributes to your larger narrative. Reflect on this tapestry periodically to understand how each achievement, irrespective of its scale, contributes to your personal and professional evolution.

Exercise:

Create a feedback repository today. As an example, if you're a software developer, jot down three programming challenges you overcame in the last six months. Attach screenshots of the solutions and write a brief reflection on each. Commit to updating this repository weekly.

What to Expect:

By maintaining a feedback repository, expect to develop a greater sense of self-awareness and resilience against Impostor Syndrome. The repository will serve as an anchor, grounding your self-perception in reality, and providing you with the motivation to continuously strive for greatness.

Example if Applied:

Consider a developer who kept a detailed feedback repository. Before a challenging project, he reviewed his repository and was reminded of his skills and past successes. This boosted his confidence, leading to exemplary performance.

Example if Not Applied:

Another developer, without a feedback repository, faced similar challenges but lacked self-assurance and reference to past successes. He performed sub-optimally due to a lack of confidence.

Tips:

• Set reminders to update your feedback repository regularly.

• Use tags or categories to organize your entries.

• Include photographs or screenshots as evidence of achievements.

• Write a brief reflection on what each achievement means to you.

Resources:

1. “Braving the Wilderness” by Brené Brown - A book that discusses the importance of belonging and self-validation.

2. Evernote, Notion, or Trello apps for maintaining a digital repository.

Conclusion:

A feedback repository is an empowering tool that can transform your professional journey. By actively cataloging your achievements and reflecting on them, you are reinforcing a positive self-image and combating the detrimental effects of Impostor Syndrome. This repository, rooted in objective evidence, serves as an invaluable resource for not only personal reflection but also for sharing and celebrating your growth with mentors and peers. It becomes the foundation upon which your confidence is built, ensuring that your perception of self is both balanced and grounded in reality.

As we conclude this enlightening exploration into building and utilizing a feedback repository, let us look forward to the next phase of this journey.

After dedicating time and effort to skill development and personal growth, it's essential to take stock of the progress made. In the next article, we will delve into the importance of conducting a final assessment and the significance of celebrating achievements. This step marks not just the culmination of a cycle, but the beginning of new possibilities, as you will be equipped with insights and the confidence to set forth on new ventures. Stay tuned as we explore how to effectively assess, celebrate, and share your learning experiences with others.

As individuals make strides on their learning paths, it is critical to pause periodically to reflect on the journey. Reflection is the mirror through which we can see our growth, strengths, and areas for improvement. It is also the antidote to Impostor Syndrome, which manifests as doubting one’s achievements and harboring a persistent fear of being exposed as a “fraud”. The relevance of reflection is in calibrating self-perception, aligning actions with values, and gaining insight into personal patterns that can either support or hinder growth.

Schedule Reflective Sessions:

Reflective sessions are not just about looking back, but also about envisioning the future. Setting a schedule for reflection ensures that individuals carve out time amidst their busy schedules to evaluate their journey. Regular reflection is key as it fosters a habit of self-evaluation and self-awareness, which are critical for personal development and mental well-being. It serves as a checkpoint to assess alignment with personal values and goals.

Guide Reflective Thinking:

Reflection is an art that requires cultivation. Here, individuals need guidance to engage deeply with their experiences. Reflective thinking involves asking oneself thought-provoking questions, analyzing actions and decisions, and evaluating their outcomes. It's essential to be open, honest, and critical without being harsh. Consider questions such as:

• What have I learned?

• How have I contributed positively to the team or project?

• Did my actions align with my values?

• What could I have done differently?

This kind of inquiry leads to insights that are crucial for personal and professional development.

Document Reflections:

Writing is a powerful reflection tool. When individuals document their thoughts, feelings, achievements, and challenges, they externalize their experience, making it easier to analyze and understand. A reflection journal or log can be a treasure trove of personal insights and a chronicle of growth over time. This record serves as tangible evidence against the distortions of Impostor Syndrome and a source of motivation during trying times.

Discuss Impostor Syndrome:

Impostor Syndrome can be debilitating. However, through open discussion, individuals can understand that they are not alone in these feelings. Facilitating a culture where conversations about Impostor Syndrome are normalized can reduce its power. Discussions can be through workshops, group sessions, or one-on-one mentoring. People can explore the roots of their Impostor Syndrome, be it societal expectations, personal insecurities, or previous experiences, and learn strategies to mitigate it.

Provide Positive Reinforcement:

One of the ways to counter Impostor Syndrome is through positive reinforcement. This involves acknowledging the achievements and efforts of individuals. Positive reinforcement builds self-esteem, motivates, and is a critical component in cultivating a positive organizational culture. When individuals receive affirmation for specific actions or behaviors, it reinforces those actions and encourages their repetition.

Focus on Tangible Evidence:

Impostor Syndrome thrives on discounting one's achievements. Therefore, focusing on tangible evidence of success is vital in combating it. This can include accolades, completed projects, positive feedback, or any other recognition. Tangible evidence serves as an anchor to reality, mitigating the distortions of Impostor Syndrome.

Develop Coping Strategies:

Teaching individuals how to manage Impostor Syndrome is key to fostering resilience. This includes strategies such as:

• Positive self-talk: Remind oneself of skills, achievements, and contributions.

• Creating a support network: Share experiences with friends, family, or colleagues.

• Seeking professional help if necessary: A counselor or psychologist can be instrumental in some cases.

• Mindfulness and relaxation techniques: These can reduce anxiety and stress related to Impostor Syndrome.

Encourage Continuous Reflection:

Reflection should not be a one-off; it needs to be woven into the fabric of an individual's life. Continuous reflection aids in calibrating self-perception, assessing alignment with values, and recognizing patterns. It fosters self-awareness, which is key to personal development.

Exercise:

Create an "Achievement Journal." Regularly document achievements, feedback, and challenges. Use this journal during reflection sessions, especially when grappling with Impostor Syndrome. It serves as a reality check and motivation booster.

Example

Achievement Journal Entry:

Date: June 20, 2023

Achievement: Successfully developed and deployed a new feature for the company's mobile app.

Details: I was tasked with developing a new in-app messaging feature that allows users to communicate within the mobile app. This was a highly requested feature from our user base, and I was eager to take on the challenge. However, integrating this feature required diving into new technologies and libraries that I hadn't worked with before.

Feedback Received: After the deployment, users quickly adopted the new feature. The product manager shared feedback from users, who expressed how this feature greatly improved their in-app experience. My team lead also praised my initiative and dedication, and my work was recognized during the team meeting.

Challenges Overcome: Implementing real-time messaging was technically challenging. I invested time in learning new technologies, sought advice from senior developers, and iteratively tested the feature. After multiple revisions and addressing unexpected bugs, I managed to create a stable and efficient messaging system.

Personal Reflection: This project was a huge learning experience and a testament to what I can accomplish when I commit to solving a complex problem. It has boosted my confidence in my problem-solving skills and my ability to learn new technologies. Although I felt anxious and doubtful at times, seeing the positive impact my work had on the product and receiving appreciation makes me realize the value I bring as a developer.

What to expect from this exercise:

• Skill Development Recognition: By documenting such achievements, developers can visually see how their skills and expertise have developed over time.

• Combat Impostor Syndrome: Developers often face Impostor Syndrome due to the constantly evolving nature of technology. This exercise serves as tangible evidence of their capabilities, which can be immensely helpful in counteracting feelings of inadequacy.

• Career Progression Insight: Regular entries can provide insights into career progression and highlight the types of projects or challenges that are particularly engaging or rewarding.

• Motivation and Goal Setting: Reviewing past achievements can serve as motivation and aid in setting new goals aligned with the developer’s aspirations and areas of interest.

Resources for Further Reading:

1. “The Reflective Practitioner: How Professionals Think in Action” by Donald A. Schön

2. “The Secret Thoughts of Successful Women: Why Capable People Suffer from Impostor Syndrome and How to Thrive in Spite of It” by Valerie Young

3. “Daring Greatly: How the Courage to Be Vulnerable Transforms the Way We Live, Love, Parent, and Lead” by Brené Brown

Conclusion:

Reflection and addressing Impostor Syndrome are integral to nurturing personal development and fostering a positive self-image. Through reflection, individuals gain insights into their actions, values, and growth, while actively engaging in discussions and exercises to tackle Impostor Syndrome bolsters self-confidence. The act of recording achievements, coupled with positive reinforcement and focusing on tangible evidence, is paramount to combating the internalized self-doubt that Impostor Syndrome perpetuates. As individuals embark on this continuous journey of self-discovery, they not only thrive personally but also contribute positively to the broader community.

Stay tuned for the next part in this series, where we will explore creating a system for individuals to record positive feedback and accomplishments, and how referring back to this repository can be an empowering tool during moments of doubt or under-confidence.

In the world of personal development, recognizing that learning and growth are not linear is essential. This is especially crucial when considering cognitive biases like the Dunning-Kruger effect and Impostor Syndrome, which can distort self-perception. Being flexible and adaptable ensures that your milestones stay relevant and aligned with your evolving needs.

Evaluate the Need for Adjustment:

It's important to periodically assess whether the milestones you've set continue to serve your development goals. Evaluating them in light of feedback and self-assessment will give you a clearer picture. Ask yourself:

• Are the milestones still relevant to my goals?

• Have I encountered unexpected challenges or opportunities that necessitate a change?

• Am I progressing at a slower or faster pace than expected?

For example, a person who set a milestone to learn a new programming language might find that the language is becoming obsolete. In such a scenario, sticking to the original milestone is counterproductive.

Make Data-Driven Adjustments:

Use feedback and evaluations to inform your decisions on adjusting milestones. If you find that you are breezing through your milestones, it might indicate that they are not challenging enough, and you might be overconfident due to the Dunning-Kruger effect. Conversely, if you’re struggling despite sincere efforts, Impostor Syndrome might be at play. Make adjustments accordingly:

• If progressing faster than expected, incorporate more challenging milestones.

• If struggling to meet milestones, adjust them to be more realistic.

Address Cognitive Biases:

While adjusting milestones, consider how the Dunning-Kruger effect and Impostor Syndrome might be affecting your self-perception. If you're consistently surpassing milestones with ease, it might be time to set more challenging objectives to combat overconfidence. Conversely, if you’re not achieving milestones despite sincere efforts, you might need to set more attainable goals to build confidence.

Communicate the Adjustments:

When milestones are adjusted, it’s important to communicate the changes and the reasoning behind them with any mentors, peers, or stakeholders involved. This ensures transparency and helps in receiving constructive input.

Document the Adjustments:

Maintaining a record of adjustments to milestones is crucial. It provides a way to review the evolution of your development plan and to understand the reasons behind each change.

Foster a Growth Mindset:

Encouraging a growth mindset is vital. By understanding that abilities can be developed through dedication and hard work, individuals are more likely to view adjusting milestones as a proactive step rather than a failure.

Exercise: Milestone Adjustment Scenario Analysis

Relevance: This exercise will help you apply the concept of dynamic milestone adjustment in real-life scenarios, and consider the influences of the Dunning-Kruger effect and Impostor Syndrome.

What to Expect: By analyzing different scenarios, you will practice making data-driven milestone adjustments and understand how they can either mitigate or exacerbate cognitive biases.

Procedure:

1. Create a table with columns for Scenario, Original Milestone, Adjustment Needed, and Rationale.

2. Fill the table with various personal development scenarios.

3. For each scenario, evaluate the original milestone, suggest an adjustment, and provide a rationale considering cognitive biases.

Resources:

1. "Mindset: The New Psychology of Success" by Carol S. Dweck. This book can help in understanding the growth mindset, which is crucial for adapting milestones.

2. SMART Goals: How to Make Your Goals Achievable. MindTools article on setting SMART goals, which should be adaptable.

Conclusion:

Dynamic milestone adjustment is the key to keeping a personal development plan responsive and effective. By evaluating, communicating, and documenting changes in milestones, we can ensure that we are on a path that truly aligns with our evolving needs and aspirations. Taking into account cognitive biases like the Dunning-Kruger effect and Impostor Syndrome is crucial in making these adjustments, as it helps in maintaining a balanced self-perception. Fostering a growth mindset, where we view changes not as setbacks but as opportunities for improvement, is essential. Next, we'll look into the importance of reflection and addressing Impostor Syndrome, which is an integral part of personal development and crucial in recognizing genuine growth and achievements. Stay tuned!

Regular check-ins are essential for keeping individuals on track, providing ongoing support, and ensuring that the plan remains aligned with development needs. They can also mitigate the Dunning-Kruger effect and Impostor Syndrome by providing realistic assessments of one’s skills and progress.

Set a Schedule for Check-Ins

Determine a schedule for regular check-ins. The frequency can vary depending on the goals and milestones. Having a set schedule creates structure and accountability.

Example: A software engineer sets a weekly check-in with a mentor to discuss progress in learning a new programming language. Without regular check-ins, the engineer might overestimate their proficiency or underestimate it due to cognitive biases.

Prepare for the Check-In

Before each check-in, individuals should prepare by reviewing milestones, evaluating progress, and considering challenges. Preparation makes the check-in more focused and productive.

Tips:

• List achievements since the last check-in.

• Provide specific examples of challenges faced.

• Consider what support might be needed.

Conduct the Check-In

During the check-in, engage in an open conversation about progress and challenges.

1. Review milestones and progress.

2. Discuss challenges, and brainstorm solutions.

3. Compare self-perception with evaluations.

4. Review feedback from evaluations.

5. Discuss additional support or resources.

6. Reflect on the overall journey and growth.

Adjust the Plan as Needed

Based on discussions, adjust milestones, evaluation criteria, or other aspects of the plan.

Concrete Actions:

• If a milestone is repeatedly missed, break it into smaller, more manageable steps.

• If new challenges arise, incorporate them into the plan with strategies to overcome them.

• If the feedback indicates skill improvement, consider raising the bar for subsequent milestones.

Set Goals for the Next Check-In

Before concluding the check-in, set specific objectives to be achieved by the next check-in. This keeps the momentum going and provides a clear focus for the coming period.

Example: If during a check-in you realize that you have been consistently missing your milestones, it may indicate that your initial plan was too ambitious. Setting more realistic goals for the next check-in can help balance ambition with achievability.

Document the Check-In

Keep a record of what was discussed during the check-in, including any adjustments made to the plan, and the goals set for the next check-in. This documentation can help monitor progress over time and ensure accountability.

Exercise: Self-Reflection Journal

Keep a journal to document your thoughts, achievements, and challenges between check-ins. Reflect on how close or far you are from achieving milestones, and what might be causing any discrepancies.

Relevance: This exercise helps to maintain a continuous engagement with one’s progress, even between check-ins. It serves as a tool for self-awareness and can be particularly insightful in identifying instances of Dunning-Kruger or Impostor Syndrome.

Resources

• "The Making of a Manager" by Julie Zhuo: This book includes insights on how to conduct effective check-ins.

• "Radical Candor" by Kim Scott: Offers guidance on how to have honest and helpful conversations.

• Agile project management tools like Jira or Trello for tracking progress.

Conclusion

Regular check-ins are a pivotal element of any successful development plan. They not only provide the necessary structure for continuous progress but also facilitate a realistic understanding of one’s abilities and achievements. Especially in the context of cognitive biases such as the Dunning-Kruger effect and Impostor Syndrome, regular check-ins can function as an external reality check. This, in turn, helps individuals calibrate their self-assessment and progressively grow in alignment with their goals.

As an ongoing process, it’s crucial to remember that learning and development are dynamic. Staying adaptable and open to change is imperative for true growth. This leads us to the next vital step in this series, which is milestone adjustment. This step focuses on the significance of allowing milestones to be dynamically adjusted based on feedback and evaluations and encourages individuals to maintain flexibility in their learning paths.

Introduction to Evaluation Criteria

Evaluating your milestones is an indispensable aspect of your development journey. It ensures accountability, learning from experiences, and provides a reality check against cognitive biases. Without evaluation, you might either overestimate your capabilities, fall prey to the Dunning-Kruger effect or underestimate your achievements, which is a hallmark of Impostor Syndrome.

Choose Evaluation Methods

For each milestone, opt for an evaluation method suiting its nature. Common evaluation methods include:

• Peer Reviews: Here, your colleagues or peers evaluate your work. This can be particularly helpful in team settings or collaborative projects.

• Mentor Assessments: A mentor or supervisor gives feedback on your progress. This is crucial for professional development, as mentors often have insights and experiences you might not possess.

• Self-Assessments: This involves self-reflection and evaluating your progress against set criteria. This can be enlightening but remember that self-assessments can sometimes be skewed by cognitive biases.

For example, if your milestone involves mastering a coding language, a peer review could involve code reviews by fellow programmers, while mentor assessments might focus on the efficiency and optimization of your code. A self-assessment might involve creating a project using the language.

Define Specific Criteria for Each Evaluation Method

For every evaluation method chosen, outline specific criteria that must be met for the milestone to be considered complete. These criteria should align with the objectives of the milestone and must be measurable.

For instance, if your milestone is to “learn the basics of Python programming,” evaluation criteria could include writing a simple Python script (self-assessment), getting feedback on your coding style (peer review), or demonstrating your understanding of Python syntax in a discussion with a mentor (mentor assessment).

Establish Feedback Mechanisms

Constructive feedback is central to the evaluation process. It provides insights into whether you’ve achieved a milestone and what can be learned from the process. Here are tips and examples for each type of review:

For Peer Reviews:

• Foster a Constructive Culture: Encourage peers to offer feedback that is both positive and developmental. Promote an atmosphere of mutual growth.

• Be Specific in Your Requests: When seeking feedback, ask specific questions. For instance, if your milestone is to improve public speaking, you could ask, “How well did I maintain eye contact during my presentation?”

• Encourage Actionable Feedback: Request feedback that you can act upon. Ask peers to offer suggestions for improvement.

• Document the Feedback: Maintain a record of the feedback received. This will allow you to track your progress over time.

Example: If you're working on project management skills, ask peers for feedback on how effectively you managed timelines and allocated resources. Ask for concrete examples of what you did well and areas where you can improve.

For Mentor Assessments:

• Schedule Regular Check-Ins: Schedule regular meetings with your mentor to discuss your progress. Consistent communication is key.

• Prepare for Feedback: Before the meeting, consider what you would like feedback on. Be open to receiving feedback on both strengths and areas for improvement.

• Ask for Clarification and Examples: If feedback is vague, ask for specific examples. If a mentor says you need to be more assertive, ask for instances where being assertive would have been beneficial.

• Reflect and Take Notes: Take notes during feedback sessions and reflect on them afterward. Create an action plan based on the feedback.

Example: If your milestone is to develop leadership skills, ask your mentor to assess your performance in recent team meetings. Discuss specific scenarios and ask for insights on how to handle similar situations in the future.

For Self-Assessments:

• Be Honest with Yourself: Approach self-assessments with honesty. Acknowledge both your achievements and areas where you fell short.

• Use a Reflective Journal: Maintain a journal where you document your thoughts, challenges, and learnings. Reflect on how your actions contributed to your progress or setbacks.

• Compare Against Criteria: Refer to the criteria you set for milestone completion. Analyze where you stand about these criteria.

• Set Next Steps: After evaluating, set actions for moving forward. This might involve adjusting your approach, seeking additional resources, or revising your milestones.

Example: If you’re working on improving your writing skills, review an article you’ve written. Assess it against the criteria you set, such as clarity, coherence, and grammar. Note areas where you met or fell short of these criteria and set actions for improvement.

By establishing feedback mechanisms and actively engaging in the evaluation process, you’re setting yourself up for continuous learning and development, while also guarding against cognitive biases.

Calibration Against Cognitive Biases

This is where evaluation becomes a powerful tool in managing cognitive biases. Utilize feedback and evaluation results to calibrate your self-perception. If you consistently exceed your milestones with minimal effort, your milestones might be too easy and may lead to overconfidence, a symptom of the Dunning-Kruger effect. If, however, you find that despite genuine effort you’re not meeting your milestones and this is causing you to doubt your abilities, this might be Impostor Syndrome taking root. Reevaluate and readjust your milestones accordingly.

Document the Evaluation Criteria and Feedback Mechanisms

Maintain records of the evaluation criteria and feedback mechanisms for each milestone. This documentation can be included where you record your milestones and should be readily accessible.

Exercise: Feedback Matrix

Relevance: It enables you to organize feedback from different sources systematically. Through this, you can gain insights into your actual performance relative to the milestones you've set. It offers a balanced perspective, which is critical in calibrating your self-assessment and negating the biases that may arise from Dunning-Kruger or Impostor Syndrome.

What to Expect: By using the Feedback Matrix, you can expect to have a structured way of collecting and analyzing feedback. You might discover areas where you underestimated your skills (relevant to Impostor Syndrome) or overestimated them (relevant to Dunning-Kruger Effect). This exercise is expected to enhance self-awareness and guide you in making informed decisions about your learning journey.

How to Do It: Create a matrix where the rows represent your milestones, and the columns represent different sources of feedback (self, peers, mentors). In each cell, jot down the feedback received for a particular milestone from a specific source. Analyze the matrix to understand trends, consistencies, or discrepancies in feedback.

Example: Suppose you have set a milestone to "Develop and deliver an effective presentation to the team on Project X's progress."

- Used data effectively but could improve on visual elements | - Engaging and informative
- Pacing was too fast at times, making it hard to follow
- Slides were visually appealing but charts need clarification | - Content well-organized
- Improve on delivery by practicing more
- Data usage was good, but consider simplifying complex charts for easier understanding |

Reflecting on the Matrix:

In this detailed example, you have more insights from each feedback source.

From your self-assessment, you recognized the structure and data usage as strengths but also noticed your nervousness. However, you might not have been aware that your nervousness affected the pacing until you received peer feedback.

The peer feedback added that your pacing was too fast at times, which might be a manifestation of the nervousness you felt. They also pointed out that while your slides were visually appealing, some charts needed clarification.

Your mentor’s feedback aligned with your self-assessment regarding content structure. They also encouraged practicing more to improve delivery, providing an actionable way to address the nervousness you identified. They further advised simplifying complex charts, which resonates with the peers’ feedback on chart clarity.

The detailed feedback matrix has enabled you to identify common threads (such as the need for clarity in visual elements), and areas where you might have been too critical (e.g., you were concerned about your use of visual elements, while others found them appealing, though needing clarification). This helps in calibrating your self-perception and formulating specific actions for improvement, thus mitigating the impact of the Dunning-Kruger Effect and Impostor Syndrome.

Additional Resources

1. Online Tool: Asana

   • Asana is a project management tool that can be useful for setting milestones and tracking progress toward goals, which is crucial for keeping cognitive biases in check.

2. Book: "Thanks for the Feedback: The Science and Art of Receiving Feedback Well" by Douglas Stone and Sheila Heen.

   • This book can be particularly useful in understanding how to interpret and use feedback effectively, which is integral to the evaluation process.

Conclusion

Defining evaluation criteria and establishing feedback mechanisms are critical components of personal and professional development. These practices not only help in tracking progress toward goals but also serve as a crucial tool in calibrating one’s self-perception, which is especially relevant in managing the Dunning-Kruger effect and Impostor Syndrome. Through this structured approach, individuals can create a more realistic view of their skills and capabilities, celebrate genuine achievements, and identify areas for improvement. Furthermore, the feedback process becomes a source of continuous learning and a catalyst for personal growth.

Stay tuned for the next article in this series, where we will delve into the importance of scheduling regular check-ins to discuss progress, tackle challenges, and make necessary adjustments to your development plan.

What are Milestones?

Milestones are key steps that pave the way toward achieving your larger goals. They serve as markers of progress and can be highly motivating. Breaking a big goal into milestones makes the process more manageable and less overwhelming.

Breaking Down Goals into Milestones

For each goal you've set, identify smaller, specific objectives that will contribute to the achievement of the goal. These smaller objectives will be your milestones.

Define Criteria for Completion

For each milestone, define what 'completed' looks like. This can be in the form of a specific output, a demonstrated skill, or any measurable criteria that signify the milestone has been achieved.

Assign Timeframes

Allocate a reasonable and specific timeframe for the completion of each milestone. Be realistic about the time needed, and consider your other commitments and potential challenges.

Align Milestones with Descriptive Concepts for Skill Levels

Consider aligning each milestone with the progression of skill levels defined in the descriptive concepts (Unconscious Incompetence, Conscious Incompetence, Conscious Competence, Proficiency, Mastery). Each milestone could be aimed at moving from one level to the next.

Example: Without Milestones

Goal: Become proficient in programming within 6 months.

Impact: This goal is too broad and can be overwhelming, leading to a higher chance of the Dunning-Kruger effect, where you might overestimate your abilities at the beginning. Similarly, as you learn more, you might feel like an imposter amongst other proficient programmers because of Impostor Syndrome.

Example: With Milestones Aligned to Skill Levels

Goal: Become proficient in programming within 6 months.

Milestones:

1. Moving from "Unconscious Incompetence" to "Conscious Incompetence" (1 month): Learn the basics of Python programming. This milestone helps by establishing a foundation and awareness of what you don’t know.

2. Moving from "Conscious Incompetence" to "Conscious Competence" (2 months): Build a small application using Python. This milestone ensures you have practical skills and application, which affirms you have gained basic competence.

3. Moving from "Conscious Competence" to "Proficiency" (2 months): Understand and implement data structures in Python and develop a complex application. This deepens your understanding, allowing you to use the skills more efficiently.

4. Moving from "Proficiency" to "Mastery" (1 month): Review, refactor code for efficiency, and make improvements based on feedback. This involves refining and innovating, indicating mastery over the skill.

Impact: By breaking the goal into specific milestones aligned with skill levels, you have a clearer focus and a structured approach to achieving proficiency. This structure can reduce the Dunning-Kruger effect by having clear and measurable milestones, and reduce Impostor Syndrome by gaining genuine competencies step by step.

Reflect on Dunning-Kruger Effect and Impostor Syndrome

While creating milestones, it is critical to be mindful of the Dunning-Kruger effect and Impostor Syndrome, as they can heavily influence your self-perception and learning process.

Dunning-Kruger Effect

The Dunning-Kruger effect is a cognitive bias where people with low ability at a task overestimate their ability, while those with high ability tend to underestimate their competence.

Too Easy Milestones

If the milestones you set are too easy or not challenging enough, this can inflate your confidence and lead to the Dunning-Kruger effect. You may quickly accomplish these milestones and start to overestimate your abilities. For instance, if you’re learning to code and set a milestone as merely installing a programming tool, this doesn’t really challenge your coding skills. Achieving this may make you feel more accomplished than you should, and you may mistakenly believe that you are well on your way to becoming an expert.

Mitigating Dunning-Kruger

To avoid this, ensure that your milestones are challenging enough to require real effort and learning. Regularly seek feedback from knowledgeable peers or mentors, and stay open to constructive criticism.

Impostor Syndrome

Impostor Syndrome, on the other hand, is a psychological pattern in which individuals doubt their skills, talents, or accomplishments and have a persistent internalized fear of being exposed as a "fraud".

Too Difficult Milestones

If your milestones are overly ambitious or too difficult, you might find yourself struggling to achieve them. This can exacerbate feelings of Impostor Syndrome because even though you are putting in the effort, the lack of progress can make you feel inadequate or like a fraud. For example, if you are new to public speaking and set a milestone to deliver a speech to an audience of 1000 people within a month, the sheer difficulty and potential struggles might lead you to doubt your abilities more than before.

Mitigating Impostor Syndrome

To combat Impostor Syndrome, create milestones that are realistic and achievable. Celebrate the small victories, and recognize that learning is a process that takes time. Also, consider sharing your experiences with peers or mentors who can offer support and perspective.

In summary, setting well-calibrated milestones - not too easy, and not too difficult - is essential in mitigating both the Dunning-Kruger effect and Impostor Syndrome. They need to challenge you enough to foster growth, but also be achievable to maintain motivation and confidence.

Regularly Review, Update Milestones and Prove Achievement

Set a schedule for regularly reviewing your milestones. During these reviews, assess your progress and make necessary adjustments to your milestones and timeframes based on your actual performance and any new information or changes that have occurred.

When you believe you’ve achieved a milestone, prove it through action. For instance, if a milestone was to code an application, then code one. This helps to verify that the milestone is genuinely achieved, and not just perceived as achieved.

Seek Feedback and External Input (Optional)

External feedback is invaluable for an unbiased assessment of your skills. It can keep you grounded if you’re experiencing the Dunning-Kruger effect and can be reassuring if you’re dealing with Impostor Syndrome.

For example, if you believe you have become good at public speaking, rather than just self-assessing, ask for feedback from a knowledgeable friend or mentor. They can provide insights that you might have missed and can help confirm or reassess the skill level you believe you are at.

Document Milestones

Record your milestones, criteria for completion, and timeframes in a format that is easy to reference and update. This could be in a journal, a digital document, or a project management tool.

Exercises

Exercise 1: Take one of your goals and break it down into at least three milestones. Write down what completion looks like for each milestone and set a timeframe for achieving each one.

Exercise 2: Reflect on your milestones and ask yourself if they are realistic and well-structured to mitigate cognitive biases. Adjust if necessary.

Additional Materials

1. Book: "SMART Goals Made Simple" by S.J. Scott - For understanding the principles behind setting effective goals and milestones.

2. Tool: Trello or Asana - These are project management tools that can be very useful in tracking your milestones.

Conclusion

By creating milestones that are well-defined, challenging, and aligned with skill levels, you not only pave a clear path for achieving your goals but also keep cognitive biases like the Dunning-Kruger Effect and Impostor Syndrome in check. Remember to stay adaptable, seek feedback, and celebrate your achievements, big or small.

In our upcoming article, we’ll be moving to evaluation criteria, where we will discuss the importance of defining how each milestone will be evaluated through peer reviews, mentor assessments, or self-assessments. Additionally, we will talk about establishing feedback mechanisms for each evaluation method to ensure that you’re not just moving forward, but moving forward in the right direction. Stay tuned!

Why are Goals Important in Skill Development?

Setting goals is an essential part of any learning or development journey. Goals give you direction, focus, and a sense of purpose. They enable you to measure progress and stay motivated through challenges. Without clear goals, your learning can be unfocused, making it easy to get sidetracked or lose motivation.

What are SMART Goals?

SMART is an acronym that stands for Specific, Measurable, Achievable, Relevant, and Time-bound. Each of these attributes is a criterion that helps in setting effective goals. Let’s break down each element:

• Specific: Your goal should be clear and specific. Vague goals make it hard to focus your efforts and feel motivated.

  Example Without Specificity: "I want to get better at math."

  Example With Specificity: "I want to improve my ability to solve algebraic equations."

• Measurable: Create criteria that allow you to measure your progress toward the attainment of your goal.

  Example Without Measurability: "I want to be more skilled in graphic design."

  Example With Measurability: "I want to create a portfolio with 10 high-quality graphic design projects."

• Achievable: Your goal should be realistic and attainable. It should challenge you, but still be possible within your abilities and resources.

  Example Without Achievability: "I want to become a leading expert in artificial intelligence within a year."

  Example With Achievability: "I want to complete an online course in artificial intelligence and work on a small project within the next six months."

• Relevant: The goal should be relevant to your interests and needs. It should align with your long-term objectives.

  Example of Irrelevance: "I will learn advanced quantum mechanics." (when your career path is in marketing).

  Example of Relevance: "I will complete a course in digital marketing strategies to improve my marketing skills."

• Time-bound: Set a deadline for your goal. This creates a sense of urgency and can motivate you to allocate your time efficiently.

  Example Without Time-bound Criteria: "I want to learn how to play the guitar."

  Example With Time-bound Criteria: "I want to learn to play three full songs on the guitar within 6 months."

Impact of Non-SMART Goals

Setting non-SMART goals can lead to issues, especially in terms of the Dunning-Kruger effect and Impostor Syndrome.

The Dunning-Kruger Effect and Non-SMART Goals

Vague or over-ambitious goals can inflate the Dunning-Kruger effect.

Example: "I want to become an expert in software development."

This goal lacks SMART parameters and may lead to premature self-perception as an expert, halting further learning.

Impostor Syndrome and Non-SMART Goals

On the flip side, non-SMART goals can amplify Impostor Syndrome.

Example: “I want to keep improving my programming skills.”

Without measurable success or achievable targets, this goal could make one feel perpetually inadequate, fueling Impostor Syndrome.

Crafting Your SMART Goals

Exercise 1: Define Your Skill Development Goals

Grab a notebook or open a document on your computer. Write down what skills you want to develop. For each skill, create a SMART goal.

For example, if you want to learn a new language, a SMART goal could be: “I will learn to hold a 10-minute conversation in Spanish within the next three months.”

Relevance: Setting SMART goals aligns your learning efforts with your objectives. It allows for clear focus, measurable progress, and timely completion.

Resource: Read “Succeed: How We Can Reach Our Goals” by Heidi Grant Halvorson for insights into goal setting and achievement.

Monitor and Adjust Your Goals

Goals should not be static. As you progress, you might find that you need to make adjustments to your goals. Maybe something was easier than you thought, or maybe you overestimated what you could realistically achieve in the time frame you set. That’s okay! The key is to be adaptable.

Exercise 2: Weekly Goal Review

Set aside time every week to review your goals. Reflect on the progress you’ve made, and consider if you need to make any adjustments to your goals. Make sure they continue to be Specific, Measurable, Achievable, Relevant, and Time-bound.

How Goals Impact Your Learning Journey

Setting SMART goals not only gives you a roadmap for your learning journey but also contributes to a sense of accomplishment. Each time you achieve a goal, even a small one, it boosts your motivation and confidence. This can create a positive cycle of learning and achievement.

Wrapping Up

Remember, the journey of skill development is just as important as the destination. Setting SMART goals is a powerful way to ensure that your journey is focused, meaningful, and aligned with your aspirations. In the next article, we will delve into assessing your current level of skill and confidence, and encourage you to plot your perceived ability on a hypothetical Dunning-Kruger graph. Stay tuned!

Further Readings:

• “The Power of Full Engagement” by Jim Loehr and Tony Schwartz

• “Drive: The Surprising Truth About What Motivates Us” by Daniel H. Pink

What is the Dunning-Kruger Effect?

The Dunning-Kruger Effect is a cognitive bias where individuals with low ability at a task overestimate their ability, and those with high ability underestimate their competence. This effect was first identified by psychologists David Dunning and Justin Kruger in 1999. When individuals know very little about a topic, they may not recognize their inadequacy. Conversely, when they are highly skilled, they may assume that others find the task as easy as they do. This creates a mismatch between perceived ability and actual ability, affecting decision-making and learning.

The Dunning-Kruger effect has two main characteristics:

1. Low-Ability Overconfidence: People with a low level of competence in a particular area often fail to recognize their lack of skill, and as a result, they overestimate their abilities.

2. High-Ability Underestimation: Conversely, highly competent individuals tend to underestimate their relative competence, often assuming that tasks that are easy for them are also easy for others.

It's important to recognize that the Dunning-Kruger effect is a form of cognitive bias. A cognitive bias is a systematic error in thinking that affects the judgments and decisions people make. In the case of the Dunning-Kruger effect, the bias lies in the inability of individuals to accurately assess their skill levels.

The Dunning-Kruger effect can have a significant impact on decision-making and behavior. For instance, an individual who overestimates their abilities might take on tasks they are not equipped to handle, resulting in poor performance. On the other hand, someone who underestimates their skills might avoid opportunities for growth or leadership, believing they are not qualified enough.

In the context of skill development, being aware of the Dunning-Kruger effect is crucial. It helps individuals to recognize the importance of continuous learning and seeking feedback. By understanding that our self-assessment may be biased, we can open ourselves to a more accurate evaluation of our skills and abilities, leading to more informed decisions and actions.

Exercise 1: Reflect on an experience where you were new to a skill and thought, “This seems easy.” Later, as you delved deeper, you might have realized there was a lot more complexity. Write this experience down.

Relevance: Understanding the Dunning-Kruger Effect helps in realizing that initial overconfidence can be detrimental to genuine skill-building. Being aware helps in curbing the bias.

Resource: Watch the TEDx talk - “Why incompetent people think they’re amazing” by David Dunning.

What is Impostor Syndrome?

Impostor Syndrome involves a persistent doubt in one's abilities and achievements, accompanied by the fear of being exposed as a fraud. Despite external evidence of their competence, those experiencing Impostor Syndrome remain convinced that they are frauds and do not deserve the success they have achieved. Such doubts can hinder personal and professional development, as individuals may avoid pursuing new opportunities or challenges.

The term ‘Impostor Syndrome’ was first coined in the 1970s by clinical psychologists Dr. Pauline R. Clance and Dr. Suzanne A. Imes. They observed that despite having adequate external evidence of accomplishments, some individuals internalized a deep-seated feeling of not being good enough and considered themselves to be frauds.

In their seminal paper titled 'The Impostor Phenomenon in High Achieving Women: Dynamics and Therapeutic Intervention', Clance and Imes initially studied the phenomenon among high-achieving women. However, subsequent research has shown that Impostor Syndrome can affect anyone regardless of gender, occupation, or background.

Impostor Syndrome is characterized by:

1. Chronic self-doubt: An ongoing sense of doubt regarding one’s abilities and achievements.

2. Fear of being ‘found out’ or exposed as a fraud: A persistent fear that others will realize that the individual is not as competent as they appear to be.

3. Attribution of success to luck or external factors: Believing that successes are not due to one's abilities but to luck, timing, or having deceived others into thinking they are more competent than they believe themselves to be."

Impostor Syndrome can have detrimental effects on an individual’s well-being and performance. It can lead to anxiety, stress, low self-esteem, and in some cases depression. Moreover, it may cause people to avoid taking on new challenges or opportunities for fear of not living up to expectations.

In the context of skill development, recognizing and addressing Impostor Syndrome is important. Individuals need to realize that feeling like an impostor does not equate to being one. Understanding that these feelings are common and not necessarily grounded in reality can help individuals to take steps to overcome these thoughts, and pursue personal and professional growth with more confidence.

Exercise 2: Think of a time you achieved something significant but felt like you didn’t deserve it. Write down how you felt and why you think you felt this way.

Relevance: Recognizing Impostor Syndrome is important because it can hinder your progress by preventing you from acknowledging your achievements.

Resource: Read “The Secret Thoughts of Successful Women: Why Capable People Suffer from the Impostor Syndrome and How to Thrive in Spite of It” by Dr. Valerie Young.

The Intersection of Dunning-Kruger Effect and Impostor Syndrome

Both Dunning-Kruger Effect and Impostor Syndrome can act as barriers to skill development. The former might cause individuals to prematurely conclude that they’ve learned enough, while the latter might make them feel like they’ll never learn enough. Both biases distort the perception of one’s abilities, and addressing them is critical for effective skill development.

Understanding the Dunning-Kruger effect and Impostor Syndrome is especially important when it comes to self-assessment and goal setting. When setting goals, individuals might overestimate or underestimate their abilities due to the Dunning-Kruger effect. Similarly, Impostor Syndrome may cause individuals to set overly conservative goals, fearing that they aren't competent enough. Being aware of these phenomena helps individuals to set more realistic and achievable goals.

By recognizing the Dunning-Kruger effect, individuals can remain open to feedback and continuous learning. This is crucial because one of the antidotes to the Dunning-Kruger effect is gaining more knowledge and expertise. Similarly, by acknowledging Impostor Syndrome, individuals can work towards building self-confidence, thereby engaging in opportunities for learning and growth without the hindrance of self-doubt.

When individuals can accurately assess their skills and manage self-doubt, they are more likely to perform effectively. Overcoming the barriers posed by the Dunning-Kruger effect and Impostor Syndrome can lead to increased focus, higher motivation, and ultimately improved performance and productivity.

Exercise 3: Plot your experiences from Exercise 1 and Exercise 2 on a graph, with confidence on one axis and knowledge on the other. Notice any trends or patterns.

Engage in Discussions

Let's move on to an activity that will help us reflect on our own experiences with the Dunning-Kruger effect and Impostor Syndrome. This reflective exercise is designed to encourage self-awareness and to identify how these phenomena may have influenced our thoughts, decisions, and actions in various situations.

• Describe a time when you felt highly confident about a skill or task, but later realized you overestimated your abilities. How did this affect your performance or outcome?

• Recall an instance where you doubted your competence despite evidence of your achievements. How did this affect your decisions or actions?

• What strategies can you use to combat the Dunning-Kruger effect and Impostor Syndrome in the future?

• Consider how different situations may have been handled if you had been aware of the Dunning-Kruger effect or Impostor Syndrome at the time.

Exercise 4: Find a friend, family member, or colleague who is open to discussing these topics. Share your experiences and listen to theirs. Discuss how these biases might have affected your learning experiences.

Tool: Use online forums or social media groups focused on personal development to find people to discuss with.

Educate Yourself Further

Now that we have explored the concepts of the Dunning-Kruger effect and Impostor Syndrome, and engaged in reflective activities, we must have the tools and resources necessary for ongoing learning and management of these phenomena. We will go through a set of resources that you can use for deeper understanding and practical application.

Here are some books and articles that provide insights into the Dunning-Kruger effect and Impostor Syndrome:

• “You Are Not So Smart” by David McRaney - A book about self-delusion and cognitive biases, including the Dunning-Kruger effect.

• “The Secret Thoughts of Successful Women” by Dr. Valerie Young - This book offers insights into why capable people suffer from Impostor Syndrome and how to thrive despite it.

Participating in courses or workshops can also be very helpful. Here are a few recommendations:

• “Learning How to Learn” on Coursera - This course covers the Dunning-Kruger effect and various learning techniques.

• “Overcoming Impostor Syndrome” on LinkedIn Learning - This course provides strategies for overcoming Impostor Syndrome.

Utilizing tools for reflection and self-assessment can help you to continually evaluate your skills and combat the Dunning-Kruger effect and Impostor Syndrome. Some tools that might be helpful include:

• Journaling: Keeping a daily or weekly journal where you reflect on your experiences, thoughts, and feelings can be beneficial.

• Feedback Tools: Utilize 360-degree feedback tools or ask for regular feedback from peers, supervisors, or mentors.

Engage with your support network. This could be friends, family, or professional networks. Sharing experiences and gaining perspectives from others can be very valuable in managing the Dunning-Kruger effect and Impostor Syndrome

Exercise 5: Watch the TED talk “Thinking you’re good at something, when you’re not” by Dr. Tomas Chamorro-Premuzic.

Exercise 6: Reflect on how this knowledge will shape your approach to setting goals for skill development.

Wrapping Up

Being aware of the Dunning-Kruger Effect and Impostor Syndrome, engaging in personal reflections, and participating in discussions are your first steps in preparing for a more informed skill development process.

In the next article, you will learn how to set SMART goals that can keep your learning focused and measurable. Stay tuned!

Understanding the Dunning-Kruger Effect and Impostor Syndrome

The Dunning-Kruger Effect is a cognitive bias where individuals with low ability at a task may overestimate their ability, while those who are highly skilled may underestimate their competence. As discovered by social psychologists David Dunning and Justin Kruger in 1999, this bias can lead to misconceptions about one’s abilities.

Impostor Syndrome, in contrast, is where an individual doubts their accomplishments and fears being seen as a “fraud.” This can cause even high-achieving individuals to underestimate their competencies.

Both the Dunning-Kruger Effect and Impostor Syndrome can create challenges in skill development by affecting self-perception.

A Brief Overview of the Skill Development Process

This skill development process aims to address the Dunning-Kruger Effect and Impostor Syndrome while encouraging purposeful learning. Here’s a brief overview of the 11 steps:

1. Educational Kickoff: Introducing the Dunning-Kruger Effect and Impostor Syndrome.

2. Setting SMART Goals: Developing Specific, Measurable, Achievable, Relevant, and Time-bound goals.

3. Initial Self-Assessment: Assessing current skills and confidence levels.

4. Create Milestones: Creating smaller, achievable milestones for goals.

5. Define Evaluation Criteria: Establish how milestones will be evaluated.

6. Regular Check-Ins: Monitoring progress through scheduled check-ins.

7. Dynamic Milestone Adjustment: Adapting milestones based on feedback.

8. Reflection and Addressing Impostor Syndrome: Reflecting on the learning journey.

9. Feedback Repository: Recording positive feedback and accomplishments.

10. Final Assessment and Celebration: Assessing achievements and celebrating.

11. Post-Process Analysis: Collect feedback for future improvements.

The Value of This Process

By addressing the Dunning-Kruger Effect and Impostor Syndrome, this process helps individuals gain a clearer understanding of their abilities, which is essential for learning and growth. It also emphasizes setting clear goals, regular monitoring, feedback, and reflection to support continuous development.

Conclusion

Skill development is an ongoing process, and understanding psychological factors is critical. This process aims to support effective skill development by integrating psychological insights with practical strategies. Stay tuned as we explore each step in detail in the upcoming articles.

Does it also happen to you? I think so!

What to do?

Most of the time, those pieces of code are not the most interesting ones:

• Write in a file

• Create a mock

• Helm chart values!

Even your idea helps you when you want to create a main, a constructor, getter and setters, toString, loops, if, switch, etc...

For example the main method: if you start tipping main you will see this popup:

And if you click (or press enter) then the code is injected:

How to create a template?

In IntelliJ, we have the notion of live templates. Those snippets will be proposed when you start typing the correct abbreviation in the correct context.

To create a snippet, I will first write the code, try to improve it, and see if it works. When I am satisfied, then I select it, open the actions and select Save as Live template:

A new page opens:

Those are all the information you will see on this page:

1. This is your new template. As you have not defined any abbreviation (shortcut) yet, the default value is "abbreviation"

2. The context in which your template will show up: you can restrict a template to a type of file. This will help to only display js template in js files, java ones in java files, and so on. Use user context to have your templates always available.

3. The abbreviation is the text that will trigger the suggestion and the insert of the template. Try to find something that you will remember! Not something like template1, template2,...

4. The description of the template. Be sure to describe what the template is pasting. For example, in the case of JUnit4 / JUnit 5 templates, it is important to specify it in the description.

5. The template. It is what will be written in your code.

6. You will be able to define variables to make your template dynamic!

I will just create a basic template for now with abbreviation demo1

When I type demo1 in the code, I have the suggestion and when I select it, the code is written:

How to create a dynamic template

It is nice to have a template, but it is nicer to have dynamic ones! Let's duplicate demo1 into demo2 and try to make it dynamic.

We can define variables by using $VARIABLE_NAME$

When I start typing demo2 and use the template, I will see that my cursor is set to where I have defined $MESSAGE$ and it is asking me to type something.

Nice! So now we have a variable. But what can we do with it? The edit variable is now available as IntelliJ detects the presence of variables in the templates. I will add a new variable to replace helloThere with a camel case of the string and use this new variable in the println:

Now I will edit the variables to insert $MESSAGE$ value first and make IntelliJ do the camel case for me. When I open the Edit Template Variables, I can see the order of the variables. IntelliJ will use the order used in the template. I can change that thanks to the 2 arrows.

I will move MESSAGE up.

Then I will in VARIABLE Expression use one of the functions available and pass MESSAGE as a parameter

And this is when I use it:

What is the next step?

Having templates is great, sharing templates is better! Imagine that all the "approved code" could be done by templates. All the snippets from API have templates. If you could review templates, updates, and share so you are sure to always use the most up-to-date code.

Let's see how to export your templates. Just go to File > Manage IDE Settings > Export Settings

Then select Live templates and Live templates (schemes) and export the zip to the best place for you:

Now we can import settings! Same path but click import settings instead. Then pick your zip file:

And select what you want to import from those settings:

And restart your IntelliJ to apply changes

Looking a bit into this export

If we open the zip file, we can see the templates folder with all templates per context.

If we dive into the user.xml, I can see my templates demo1 and demo2!

Next step: find out a workflow to share those templates with a broader audience!

Extra tips

When you go to a conference, and the presenter is doing a demo. And you see this kind of code :

And when he types function1, then a huge part of code shows up and you think: Wooooow, where does that come from ??? TEMPLATE

I am sure that he wrote the whole code, then extracted the part he wanted into templates, wrote down the abbreviation and when to play them and VOILA!

In conclusion, use templates!

What is more to say, repetitive code is a source of error. If you start to copy/paste snippets, and the source starts to be old, and you apply it everywhere, and it spreads, what will it look like after some time?

By managing templates, reviewing them, and sharing them, those templates will live and that redundant, unsafe and boring piece of code will become attractive, useful and safe!

How my work can looks like

When I start working on a task, I create a new branch and push commits on this branch. I may push on Friday a commit to save my work in case something happens during the weekend (to me or my laptop). I can also push a commit to trigger a pipeline to see how it will react to my changes. I often push a commit based on Sonarqube review (or any other tools like WhiteSource,...)

In the end, my tree history can look like this:

I feel sorry for the person doing the review... There is too much noise on the list of commits, hard to point out what was done, what might be reverted, etc, etc...

Even from my point of view. Let's say I have to stop working on it for few days (or weeks), when I go back on it, this won't help me!

Rewrite the story

When I end up in this situation, I try to rewrite the story: rewrite the git history. To do so, I use git rebase in the interactive mode. Thanks to it, I will be able to do several actions on this list of commits:

# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.

To clean my PR, I only use:

• pick to keep the commits that have a meaning

• reword to fix typos, include more details, rephrase my commit message

• squash to merge several commits and rewrite the message in one action. This can happen when 2 commits are on the same feature and the message should be changed

• fixup to merge several commits and keep the message of the first commit. This happens for commits with code typos, commits with back-and-forth push / revert to try things on the pipeline, etc...

How I do it technically

As for every git feature, you can use git-cli for that. You can find all the details here.

I want to show you how to do it in IntelliJ (I am sure your favorite idea is also capable to do it).

IntelliJ has a git plugin. When you open it, you will see the git history of your project (local and remote)

I have selected my branch GIT_REBASE and I will see the all the commits (from Create a feature to Update test)

When I right click on the first commit (Create a feature), I see a menu with all the options:

I click on Interactive Rebase from Here and IntelliJ opens the wizard to apply my rebase options

On top, there is the list of options I can apply to the commits:

• Up / Down to change the commit orders

• Reword to change the commit message

• Squash / Fixup (only available if it is not the first commit of the tree)

• Drop

I will select the first Fixup commit:

Now my tree looks like this.

Let's keep going by doing all the fixup first. We can "stack" several fixup:

So all the fix commits have been marked as fixup. I still have 3 commits:

• Create a feature (the first commit that I want to keep like that)

• Apply review: I want to keep it but I want to rewrite the message

• Update feature 2: I want to keep it like that also.

I select Apply review commit, click Reword and now I can see this input field

Better no?

When all my changes are done, I just need to click Start Rebasing:

Now I have my nice tree and can create a PR with 3 commits with lots of value.

If at any point, you are blocked, you can always cancel the rebase:

git rebase --abort

So now only thing that you have to do is to push your PR. If you already pushed it, you will have to do a push force:

git push -f

Conclusion

Git is a powerful tool and can help us in our work. When we submit a PR, we have to consider that someone will look at it. They will look at the code, but the commit history can also be a great source of information.

So clean it before you submit it, you will look more professional, and it will make the process smother!

Manual tasks can be incredibly tedious, time-consuming and unrewarding. The entire process can be incredibly complex and require a lot of interaction. It’s this very complexity that can sometimes stop people from attempting a task, or make someone tackling them a hero.

The tools I created allowed me to be seen as a problem solver and a situation saver. I could quickly and easily help people with their problems and get them out of a bind that they couldn't have gotten out of without my help. I was able to be the hero without anyone knowing what I was doing. It was like a superpower that only I knew about.

Creating tools and process that only you know how to use, what they do, and why they do it, may seem like a great way to bolster your position in the company. After all, you’re the only person who knows how to use them and you’re the only person who knows what they do and why they do it.

But, while this might make you feel secure, it’s not the best way to make yourself shine. If you’re the only one who can use the tools, then you become a blocker.

You become so focused on growing and protecting your secrets that you're locked into a cycle of keeping your secrets and hoping that new use cases will emerge.

You're also missing out on the potential benefits of collaboration. When you collaborate with others, you can learn from their experiences and create even more powerful solutions. This is especially true when it comes to problem-solving, as collaboration can help you brainstorm potential solutions more quickly and efficiently.

When you take that step to share what you have created, it allows for more engagement and input from your peers, thus validating your efforts. This kind of openness also allows more people to provide their critiques and suggestions, pushing you to further refine your solutions.

Then, you are no longer simply focused on your secret projects, but also on how to make your work more global in scope, both in terms of distribution and advertising. This is a tremendous opportunity for improvement and development, enabling you to put your skills and knowledge to even better use.

Moreover, with this kind of openness comes a sense of true recognition and appreciation. When others can see and experience the results of your hard work, rather than praising you through some sort of magical framework, it becomes that much more rewarding–and motivating. When people are exposed to and understand the fruits of your labor, they can more aptly appreciate it, and that elevates your necessary sense of validation.

All in all, the benefits that come from having increased transparency in your work are invaluable. By opening up your efforts to your colleagues, you are guaranteed to receive the kind of knowledge and feedback that will take your projects to the next level.

Now that you’ve revealed your secrets and taken an honest look at yourself and your skills, you’re likely to find that you’re viewed more positively and you’re likely to receive the recognition and appreciation you deserve from your colleagues and company.

Gone are the days of relying on secret tools and old-fashioned methods to get work done, as people are instead recognizing your skills and your efforts as valuable assets to their team.

You have shown your colleagues and company that you are not merely a tool – you are a source of knowledge and a problem-solver. People will perceive you as someone who is valued for the skills they bring to the table, and not just a “secret tool”.

That kind of respect can only be earned, not given.

As someone who reveals their secrets and shares their knowledge freely, you will be identified as a team-oriented person, which is invaluable in the workplace. Your newfound power will offer you great opportunities!

You have not just shown others that you are capable and confident, but trustworthy and capable of much more. Trust is the foundation of any successful business, and revealing your business secrets is a great way to build that trust with colleagues and employers.

You have the power to create a positive work environment and contribute to the success of the company with your knowledge and problem-solving skills.

Dunning-Kruger Effect

Ahhh, Dunning-Kruger Effect, is the most intriguing of all cognitive biases!

Have you ever wondered why sometimes people are overconfident in their knowledge, skills and abilities and why they don’t recognize their competence gaps?

The Dunning-Kruger effect is a psychological phenomenon that explains it all. Developed by social psychologists David Dunning and Justin Kruger in 1999, it describes the ‘cognitive bias that causes people to overestimate their knowledge and capabilities’.

To understand the Dunning-Kruger effect better, let’s break it down into four phases:

1. Unskilled and Unaware (know nothing): This is the first phase of the Dunning-Kruger effect. People in this phase lack the knowledge and skills needed to accurately evaluate their abilities and thus, overestimate their abilities.

2. Moderate Skills and Unaware (peak of "Mt. Stupid"): This is the second phase of the Dunning-Kruger effect. In this stage, people are slightly more informed than in the first stage but are still unaware of their areas of improvement. As a result, they tend to overestimate their skills in comparison to their peers.

3. Highly Skilled and Unaware (Valley of despair): This is the third stage of the Dunning-Kruger effect. People in this stage are highly competent in certain areas, but they still haven’t yet realized the competency gap that lies between them and experts. Thus, they overestimate their abilities greatly.

4. Expert and Aware: This is the last (and the most optimal) stage of the Dunning-Kruger effect. People in this stage are aware of the limits of their knowledge and skills, and thus, don’t overestimate their abilities any longer.

What impact does it have on our life?

The effect of Dunning-Kruger can be seen in many different aspects of our daily lives, including work, school, relationships, and even politics.

It can lead to people forming attitudes and beliefs that are inaccurate and oftentimes, unsafe. As a result, the inaccurate assumptions made by people in this stage can have very real consequences on the lives of others.

How to Overcome Dunning-Kruger Effect?

The best way to overcome the Dunning-Kruger Effect is to recognize that you may not know as much as you think you do. Make sure to stay humble and open-minded, and strive to become an expert in your chosen field.

Additionally, be aware of your skills and how you can improve them. Invest in yourself and take feedback constructively. Finally, be wary of those who appear to be highly skilled and knowledgeable but don’t want to admit their flaws or gaps in knowledge.

The Dunning-Kruger Effect is an interesting phenomenon that is worth taking notice of! Be sure to recognize it when you come across it and work to overcome it.

Imposter syndrom

Do you ever feel like you don't know quite enough to succeed like you're an impostor? If you do, you're not alone! Imposter Syndrome is a phenomenon where, despite their accomplishments and abilities, an individual doubts their skills, intelligence, and accomplishments, attributing any success to luck rather than actual merit.

Imposter Syndrome can have a major impact on your work. People suffering from it may:

• experience heightened levels of stress, anxiety and depression

• irrationally second-guess their accomplishments

• place unrealistically high expectations on themselves

• procrastinate out of fear of failure

• avoid taking on new challenges

• find it difficult to receive and accept compliments

• have difficulty delegating tasks to others

Recognizing Imposter Syndrome can be difficult, as it often manifests as personal feelings of inadequacy or insecurity. Here are some of the tell-tale signs:

• Comparing oneself to others, feeling they are not as smart, talented, or qualified

• Having an irrational fear of making mistakes

• Avoiding taking credit for achievements and praise

• Isolating oneself out of fear of being exposed as an impostor

• Needing to be “perfect”

Imposter Syndrome is closely related to the Dunning-Kruger effect, which suggests people with low expertise may overestimate their ability, while those with high expertise may underestimate it out of self-doubt. This can lead people with high levels of intelligence to suffer from Imposter Syndrome, as they are more aware of the complexities of a situation and feel their actual understanding is lacking.

A key way to combat Imposter Syndrome is to develop concise self-affirmations, focusing on what you have achieved and can do. It can also be beneficial to see a therapist who can help you address the underlying feelings of insecurity that lead to the Imposter Syndrome and learn more efficient ways of problem-solving.

If you think you may be suffering from Imposter Syndrome, don’t be embarrassed to seek help. Many excellent professionals can help guide you toward a solution.

Egoless programming

Egoless programming is all about de-coupling the developer from their code, acknowledging that even the best developer can produce code that requires improvement.

When it comes to the review process, a critic should be seen as someone who has a higher opinion of us and our capabilities. That’s why if a review comes back and says we can do better, it should be taken as a sign that the reviewer thinks we are capable of even more greatness.

No matter how talented we are, there will come days when our code isn’t as great as other times. This is completely normal and doesn’t take away from the developer’s talent, nor implies that they are not a great coder.

Egoless coding is all about embracing this cycle of highs and lows, dissociating ourselves from how well a particular piece of code works.

It may be tough at first: we all get attached to our hard work. But once we learn to accept and move on from our less-than-perfect code, it can be liberating and help boost our self-confidence.

So whether we are coding for the first time or an experienced coder, egoless coding is a great practice to cultivate. And who knows, it may just help make us better developers in the long run.

My plan for the future

Know you are more than one skill

We all have that one core skill that defines us: developer, manager, designer, researcher, etc. We use this as a label for ourselves to make it easier for us to focus on and get better at what we are doing.

However, this can quickly spiral into Imposter Syndrome. We tell ourselves that if we aren't perfect at this one skill, then we don't belong in our profession.

It's time to take a step back and reassess our definition of ourselves. Instead of seeing ourselves as one big skill, we need to break it down into its most basic components. For developers, this could mean taking a look at the individual programming languages and related technologies they know, as well as their software craftsmanship, testing, and debugging abilities.

Assessing our level of proficiency in each component of our core skill can help us more accurately gauge how skilled we are at our profession. It also allows us to more effectively focus on the areas where we need to do better, rather than putting all the onus on ourselves concerning the "one" skill.

In short, don't box yourself into one core quality – think of yourself in terms of all the individual components that make up your career. Assessing yourself on a more granular level can help to lift the sense of pressure and Imposter Syndrome we experience.

Know where you are

So, how do we identify our skill level and locate ourselves on the Dunning-Kruger Path? A great place – and potentially the easiest – to start is by asking our colleagues for their honest opinion of our capability. This is by no means the only way, but by contrasting our point of view with theirs, it is much easier to identify our place on the path.

If you view yourself as highly capable in certain areas, yet your peers do not, you may be on the mountain of the Dunning-Kruger Path. If you view yourself as having very little ability in certain areas, but your colleagues think otherwise, you may well be in the valley.

The important thing to remember is that there is no harm in being on the mountain, as it means that you have room to progress and develop further.

Identifying your place on the Dunning-Kruger Path is a vital step in improving your sense of self-worth and developing the skills necessary to be the best at what you do. So, don’t be afraid to ask your colleagues for help – you must put your ego aside and recognize the role others can play in helping you improve.

Know what you need to know

It can be daunting when you're suddenly asked to take on a new role like managing a team that is far more competent or experienced in certain fields than you. You might be feeling like a fraud and wondering why you are even there and if you can do the job justice.

But don't panic! Just remember that every position requires a different type of skill set and you don't necessarily have to be the best technically to lead the team. After all, no one expects a football coach to be able to play better than the team. They just have to have specific qualities and abilities to enable them to coach the team and help them reach their full potential.

It's about finding the relevant skills you have that make you an ideal candidate for the job. A good manager can lead the team by setting clear direction, delegating tasks and providing support when needed. Yes, there may be competencies and areas of expertise that the team holds that you lack. However, this doesn't necessarily mean that you can't be a great manager.

You don't simply have to replicate the same skills and knowledge as your team. Leaders should be willing to embrace new mindsets and develop serviceable skills. Building communication and relationships are also essential to being a successful manager.

Taking on any new role is never easy and having to manage a team made up of experienced experts can be nerve-racking. But by acknowledging the skills that you have and learning the ones that you don't, you can be more confident in your ability to make a positive impact in the new role.

Conclusion

Recognizing our own cognitive biases is essential to our lives and work. By being mindful of the possibility that our views may be clouded by preconceived notions, we can begin to make decisions more consciously. While we can never entirely remove the influence of bias from our decisions, by understanding the nature of our biases, we can learn to live with them and make the best decisions possible.

I was there in 2019 for my first time and I was focusing on tech talks only. But this time, with current stressful context (COVID, war, Global warming, inflation), I also wanted to join some soft skill talks, to listen to people that share my interrogations, how they handle them, what are their conclusion on their action, etc.

Soft skill talks

My career path

During this talk, if I have to remember only one thing is that an engineer is not a junior manager!!! Don't let them tell you that the only step after senior engineer is manager! There are other way to stay in engineer world:

• staff engineer,
• principal engineer,
• distinguished engineer.

I will try to also keep in mind that a career is not a straight line and it is ok and normal to take turns, to come back, to jump over, to take a break, to focus on where we are.

My mental health

This talk was mind blowing : I knew all, all was common sense, I apply nothing in my life! We all see those position in LinkedIn:

Search full stack senior engineer, DevOps, Java, Python, C#, React, Angular, Kubernetes, Docker, AWS, Azure, Google cloud, worked with high performance / distributed / critical systems, wrote 2 books, involved in community, amazing social skills, mentor, climb, sporty, speak 10 languages.

When this is the norm in our profession, one tends to overwork to learn all those things, do all those things, in hope to reach this Graal position!!! Until burnout.

So now, I will try to apply few of his advices to release the pressure on my mind and enjoy who I am as an engineer, enjoy learning to grow as en engineer.

Conclusion

Those 2 talks were the only one I followed. They either learned me new things, or make me realise I don't apply to myself what I would recommend other people to do. I think we are an industry focused on tech and evolutions and sometimes, to take a step back to focus on ourself is vital for our future.

There were more during the event and I will watch them also for sure when they are available on youtube.

Pure tech talks

I chose tech talks mostly based on the stack I am working on:

• Java (Quarkus / Spring) in backend
• MySQL, Neo4J, Redis, S3 for the data
• React in frontend
• Event-driven (Kafka, RabbitMQ)
• Rest, gRPC
• TDD (JUnit 5), Acceptance tests (Cucumber), Performance (k6)
• Docker, Kubernetes
• Gitlab, Whitesource, Sonar
• AWS

The goals were:

• to (un)validate the way we use those techs
• to learn how to fully use those techs
• to learn about the future of those techs
• to learn about alternatives to those techs

Event / Decision driven

During this talk, I learned that instead of event driven architecture, we should call it decision driven architecture. The reason behind that is that your process listen to event, but the decision you take based on the event is the logic of your process.

I also learned how to "recover" or "redo" a list of events. You can either replay all the events from a certain time but it can also be worth it to generate snapshots and fetch this snapshot and only replay the list of events from this snapshot. In our stack, we are doing the snapshot manually while we could move this task to our Kafka for example.

To make it simple : our way of thinking is correct, our implementation could be improved.

K6 not only for REST

In our stack, we have different type of exchange between each elements:

• REST
• gRPC
• Kafka
• Database

At the moment, we only run automatic performance tests on our REST layer. With k6, we can also do performance test on other layer of our application like gRPC (not for the stream), Kafka, DB. We could easily implement tests on those layer to validate:

• our configuration like topic replication, partitioning, ...
• our configuration in terms of setup : CPU, memory, network
• calculate our burst limit for each component of our stack

One final step would be to have those results pushed to Grafana, and of course, there is a plugin for that

gRPC vs REST

This talk is great for someone doing REST api, and wondering what is gRPC about. I like the approach that gRPC is not there to replace REST everywhere but can solve performance issue in term of (de)serialisation created by json format, is recommended for backend to backend communication (who need a REST with JSON in backend to backend... ok I have a lot of those...)

So something we have to change in our stack, or start to apply in our future development.

Release note / Changelog

During this presentation, we have seen the whole process between :

• I have a new version
• Consumers use this new version

This process will contain several steps like creating the release version, make it available, create a release note / changelog, package the new version (homebrew, sdkman,...), notify users (slack, emails, ...) and all that with only a configuration file.

At my level, the release note / changelog is something that we have to implement for several reason:

• in an 2 week sprint tempo, with a microservices stack, it is difficult to know what is deployed.
• in case of a rollback on a service is needed, we know to which state we go back and what are the feature not deployed (an thus the impact of the rollback on the rest of the stack)
• easier communication with the rest of the team / consumer of the services.

Apocalypse Now

This presentation rings a bell. Recently we had some strange behaviour on our system, and tech support didn't managed to solve it by themself:

• lack of documentation
• lack of training

Our documentation is written by us, developers, people who know about our system. It obviously contains shortcuts in the explanations, misses several why / who / how / when / what details, is tested by us only.

Where does it lead us to ? A disaster!!!! (or a Sunday morning call from tech support). A shame as we have the knowledge but failed to share it. The recommendation to prevent this is to do regular training by putting people in front line in a fire situation and see how well they perform with all the information / documentation they have or can find and take action from there!

We are a software company, with a passion for games, board games, video games. I would like to introduce to test our processes in a "fun and interesting" way : a Dungeon & Dragons about our apocalypse!!!

Conclusion

I went to other talks that did not trigger any alarm for me but the list above are talks that even a tiny part of them made me realise that I am missing something, that I could do something in a better way, that I could use some tools their limits.

Conclusion on Javazone

I learned a lot in both tech and soft skill and now I have the responsibility to share them with my team and see what we can take, what we can plan, and see if we can grow from it until next Javazone!!!!

You get crazy, code as much as integration test as you can, it is so easy and finally push to your favourite CI/CD pipeline.

And now everything is red in your test job!!! Whyyyyy??? Well, your sys admin removed the dind from the runners... Yes using dind can create a security breach in your pipeline...

Of course they tell you that you can start a service (gitlab services for example) and plug your tests on it but you want it to work locally so having to start (maintain) a container, inject the correct urls, be sure to clean / setup the content properly,... no thanks.

We want to have something inside of the code.

We will see how to setup your Kafka cluster inside of your integration tests.

Create a Quarkus project

Let's go to https://code.quarkus.io/, create a new project with those dependencies:

• SmallRye Reactive Messaging
• SmallRye Reactive Messaging - Kafka Connector

Now let's remove the classes generated (in main and test) and the META-INF

Create a new service KafkaService:

import io.smallrye.mutiny.Multi;
import java.time.Duration;
import javax.enterprise.context.ApplicationScoped;
import org.eclipse.microprofile.reactive.messaging.Incoming;
import org.eclipse.microprofile.reactive.messaging.Message;
import org.eclipse.microprofile.reactive.messaging.Outgoing;
import org.jboss.logging.Logger;

@ApplicationScoped
public class KafkaService {

  public static final Logger LOGGER = Logger.getLogger(KafkaService.class);

  @Outgoing("demo-kafka-out")
  public Multi<Message<String>> produceData() {
    return Multi.createFrom().ticks().every(Duration.ofSeconds(1))
        .map(tick -> Message.of("SmallRye Hello " + tick));
  }

  @Incoming("demo-kafka-in")
  public void consumeData(String message) {
    LOGGER.infov("Message received {0}", message);
  }
}

We have a simple example with one producer that will push every second a message and one consumer that will log this message.

We have to set the properties:

mp.messaging.outgoing.demo-kafka-out.connector=smallrye-kafka
mp.messaging.incoming.demo-kafka-in.connector=smallrye-kafka
mp.messaging.outgoing.demo-kafka-out.topic=demo-kafka
mp.messaging.incoming.demo-kafka-in.topic=demo-kafka
mp.messaging.outgoing.demo-kafka-out.value.serializer=org.apache.kafka.common.serialization.StringSerializer
mp.messaging.incoming.demo-kafka-in.value.deserializer=org.apache.kafka.common.serialization.StringDeserializer

Create a new empty test from KafkaService:

package com.snoirot;

import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Test;

@QuarkusTest
class KafkaServiceTest {

  @Test
  void testKafkaService() {

  }
}

So if we run this test, our test will be green and we can see some docker logs:

Test without dev service

First thing, we have to tell Quarkus to not use dev services but only for test profile:

%test.quarkus.kafka.devservices.enabled=false

If I run the test again, there is no docker logs anymore and we have a message saying that the connection to broker could not be etablished.

Setup QuarkusTestResourceLifecycleManager

Now we have to start a Kafka at the beginning of our test.

To do that, we will use QuarkusTestResourceLifecycleManager

We will create a KafkaTestResource that will implement QuarkusTestResourceLifecycleManager and start a Kafka broker there.

We need two dependencies that will contains the Kafka broker:

    <dependency>
      <groupId>com.salesforce.kafka.test</groupId>
      <artifactId>kafka-junit5</artifactId>
      <version>3.2.3</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.kafka</groupId>
      <artifactId>kafka_2.12</artifactId>
      <version>2.8.0</version>
      <scope>test</scope>
    </dependency>

Now we can create KafkaTestResource:

public class KafkaTestResource implements QuarkusTestResourceLifecycleManager {

  public static final Logger LOGGER = Logger.getLogger(KafkaTestResource.class);

  private SharedKafkaTestResource sharedKafkaTestResource;

  @Override
  public Map<String, String> start() {
    sharedKafkaTestResource = new SharedKafkaTestResource().withBrokers(3)
        .withBrokerProperty("auto.create.topics.enable", "true");

    try {
      sharedKafkaTestResource.beforeAll(null);
    } catch (Exception e) {
      LOGGER.error("Error starting kafka broker", e);
    }
    return Map.of( "kafka.bootstrap.servers", sharedKafkaTestResource.getKafkaConnectString());
  }

  @Override
  public void stop() {
    if (sharedKafkaTestResource != null) {
      sharedKafkaTestResource.afterAll(null);
    }
  }
}

This SharedKafkaTestResource would normally be used as an extension in Unit Tests with JUnit 5:

@RegisterExtension
    static final SharedKafkaTestResource sharedKafkaTestResource = new SharedKafkaTestResource()
        .withBrokers(1)
        .withBrokerProperty("auto.create.topics.enable", "true");

and it will call the beforeAll to start the cluster and afterAll to stop it.

As I want to have an Integration Test, I have to call those methods myself.

This KafkaTestResource will return a map that will override the config map:

return Map.of( "kafka.bootstrap.servers", sharedKafkaTestResource.getKafkaConnectString());

It is really useful as the port of the broker is not fixed.

Now i just have to call this resource from my test:

@QuarkusTest
@QuarkusTestResource(value = KafkaTestResource.class, restrictToAnnotatedClass = true)
class KafkaServiceTest {
`

I recommend to use restrictToAnnotatedClass in case you have several Integration Tests.

Let's run the test. I see some exception about some module. I will just add this arguments to my test:

--add-opens java.base/java.lang=ALL-UNNAMED

Let's run the test again and see that the Kafka is started.

Create a test

To create a test, I will use Mockito and Awaitility:

     <dependency>
      <groupId>org.awaitility</groupId>
      <artifactId>awaitility</artifactId>
      <version>4.1.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-junit5-mockito</artifactId>
      <scope>test</scope>
    </dependency>

NB : We can remove quarkus-junit5 dependency as it is included into quarkus-junit5-mockito

For my test, I will inject a Spy of my KafkaService and see if there is some call of consumeData which will mean my integration is working.

import static org.awaitility.Awaitility.await;

import io.quarkus.test.common.QuarkusTestResource;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.mockito.InjectSpy;
import java.time.Duration;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

@QuarkusTest
@QuarkusTestResource(value = KafkaTestResource.class, restrictToAnnotatedClass = true)
class KafkaServiceTest {

  @InjectSpy
  KafkaService kafkaService;

  @Test
  void testKafkaService() {

    var startTime = System.currentTimeMillis();
    await().atMost(Duration.ofSeconds(10)).until(() -> System.currentTimeMillis() - startTime > 9000);

    Mockito.verify(kafkaService, Mockito.atLeastOnce()).consumeData(Mockito.anyString());
  }
}

I use the await to wait 9 seconds as it can take time before the consumer get registered from the cluster.

I run the test, everything is green!

Conclusion

We have seen that we can start a Kafka cluster inside our Integration Tests using kafka-junit5 and a bit of imagination.

I recommend you to go read their github so you can create more complex Integration Tests in the future!