one-liners | For varying levels

The easy answer is to put all of the one-liners into a .bat file script and run the .bat file script.

More than likely, the cmdlet of Add-TeamUser accepts input by pipeline. Id run a Get-Help Add-TeamUser -Full to see what type of values it accepts so you can just pipe to it. Alternatively, you can just assign the value to a Variable and send it to the next command. In this scenario, we have an array of values and we loop through each one, grabbing JUST the ID, and then adding them by the ID:

you can try concat+groupby.max

I am developing a library for working with files and want to make it as easy to use (i.e. not having to worry about exceptions), but also as complete as possible (i.e. allow for proper exception handling).

It's java. Exceptions are part of the language. Reinventing the exception system is mostly just going to lead to a bizarre library that doesn't fit in with the rest of java.

do one simple thing when an exception is thrown (e.g. print the stack trace, show a popup)

psv main is allowed to be declared as throws Exception. More generally, if you want to handle all exceptions in the same way, let the exception bubble all the way to the top, and register an exception handler e.g. via Thread.setDefaultUncaughtExceptionHandler.

If you just hate checked exceptions, you probably shouldn't be using java. However, if you somehow must go against the grain, there's always UncheckedIOException that you can throw, which makes that whole 'bubble up to the top, register an uncaught exception handler' a little bit easier.

Is this still bad practice

Yes. Writing non-idiomatic java is bad practice.

To clarify, you want to achieve this:

You can use:

The documentation says "execute the named program with the given arguments". There even is a specific paragraph:

Unlike the "system" library call from C and other languages, the os/exec package intentionally does not invoke the system shell and does not expand any glob patterns or handle other expansions, pipelines, or redirections typically done by shells.

So the code in the question executes echo with the arguments 'pgc:password', |, sudo, and chpasswd. This is successful as echo can totally print those four strings.

The solution is to start chpasswd directly and write to its standard input. This is a minimal example:

The Go spec section on assignments tells us that this is the

second form

of tuple assignment. It goes on to say:

The assignment proceeds in two phases. First, the operands of index expressions and pointer indirections (including implicit pointer indirections in selectors) on the left and the expressions on the right are all evaluated in the usual order. Second, the assignments are carried out in left-to-right order.

So the compiler computes that second and s are to be assigned by evaluating them for assignment purposes—which just produces their names, more or less¹—and also evaluates the right hand side expressions in

the usual order

which means we must go look at what "the usual order" means, by following the link. This gets us to Order of evaluation.

The text here is a bit tricky, but the example is quite instructive:

in the (function-local) assignment