* }
 * }
 *
 * @author Ben Yu
 * @since 12.0
 */
/*
 * A nullable bound would let users create a TypeParameter instance for a parameter with a nullable
 * bound. However, it would also let them create `new TypeParameter<@Nullable T>() {}`, which
 * wouldn't behave as users might expect. Additionally, it's not clear how the TypeToken API could
 * support even a "normal" `TypeParameter<T>` when `<T>` has a nullable bound. (See the discussion

        request.setSessionId(getSessionId());

        // CRITICAL: Set the binding flag per MS-SMB2
        request.setSessionBinding(true);

        // The actual transport send would need proper integration
        // This would be sent on the NEW channel's transport, not the existing one

        log.debug("Channel binding prepared for channel {} with session 0x{}", channel.getChannelId(), Long.toHexString(getSessionId()));
    }

</div>

////

## Read env vars in Python { #read-env-vars-in-python }

You could also create environment variables **outside** of Python, in the terminal (or with any other method), and then **read them in Python**.

For example you could have a file `main.py` with:

```Python hl_lines="3"
import os

name = os.getenv("MY_NAME", "World")
print(f"Hello {name} from Python")
```

/// tip

   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code
   * next} field is lazily initialized. The type of that field would be {@code @Nullable T}, and the
   * code would be responsible for populating a "real" {@code T} (which might still be the value
   * {@code null}!) before returning it to callers. Depending on how the code is structured, a

   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code
   * next} field is lazily initialized. The type of that field would be {@code @Nullable T}, and the
   * code would be responsible for populating a "real" {@code T} (which might still be the value
   * {@code null}!) before returning it to callers. Depending on how the code is structured, a

      <artifactId>plexus-xml</artifactId>
    </dependency>

    <dependency>
      <groupId>javax.inject</groupId>
      <artifactId>javax.inject</artifactId>
      <!-- only for backward compatibility otherwhise would be provided -->
      <scope>compile</scope>
    </dependency>
    <dependency>
      <!-- only for backward compatibility -->
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>

Unified source directory

 Unified source directory structure that is analogous to the repository
 itself. This way locations of intermediary artifacts of a build would be
 in a known location. This would also help with developer setup i.e. getting
 new developers up and running. They could run a maven command and have all
 their source trees set up in the same way as their colleagues.

        MavenProject project = new MavenProject(model);

        // The old broken implementation would have done:
        // var plugin = getBuild().getDelegate().getPluginsAsMap().get(pluginKey);
        // return plugin != null ? new Plugin(plugin) : null;
        // This would create a disconnected Plugin that doesn't persist changes.

        // The new fixed implementation does:

      Stopwatch s = Stopwatch.createStarted();
      // here is where you would do something
      total += s.elapsed(NANOSECONDS);
    }
    return total;
  }

  @Benchmark
  long manual(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      long start = System.nanoTime();
      // here is where you would do something
      total += System.nanoTime() - start;
    }
    return total;
  }

   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code
   * next} field is lazily initialized. The type of that field would be {@code @Nullable T}, and the
   * code would be responsible for populating a "real" {@code T} (which might still be the value
   * {@code null}!) before returning it to callers. Depending on how the code is structured, a