What are the signs of a veteran sysadmin?

>5,10,15+ year Not best indicator, some will do 5/10/15/... years and not know a thing beyond they day they started, others (rarely) at less than 5 years will be flying past those with 10+ years experience like they were standing still. So, green (novice) vs. "veteran" (sr.), (very competent, skilled), typical examples (some will vary by OSes or flavors thereof, feel free to think of comparable examples as relevant for various operating systems/environments): * vi(1) * novice: to move cursor from leftmost position to (about) 70th column will hit the "l" key lots, then press and hold for auto-repeat, try and leg to at right time, then adjust to the desired position. Or worse yet, they'll copy to Microsoft Windows, edit there, copy back, they won't use vipw on /etc/passwd leaving it folded at every 80th column and lines <CR><LF> terminated seriously breaking things. Novice will at best generally be quite inefficient with vi. * sr.: will type 70| or 69l or some other few keystrokes to get straight away to exactly the desired position. sr. will also fly thorough vi so incredibly fast and efficiently that even the intermediates will often be like: "Uhm, *how* did you do that?!?!?!" * sh(1), etc. * novice: will struggle with most anything beyond (or even) basic shell stuff, e.g. simple redirection of stdin/stdout from/to files, pipes, asynchronous execution, etc. They'll barely and inefficiently navigate/edit shell history for re-execution - if they're even aware of shell history * sr.: will whip up useful powerful complex shell commands on-the-fly lickety-split. They'll highly efficiently utilize shell history to re-execute commands or edited versions thereof. Things quite useful on a regular basis and fairly non-trivial will tend to turn into saved scripts/programs, and be reasonably documented. They'll also be quite robust and accident resistant - e.g. well checking exit/return codes and appropriately handling exceptions. * commands - general * novice: may not fully, or sometimes even barely, understand the command they're about to run, exactly what it does, and how. * sr. They'll quite thoroughly know often to extreme detail, what they command they're about to run will do, and exactly how * foreseeing issues/problems, recognizing patterns/issues/problems * novice: will often miss these things. May sometimes have an inkling or "funny" feeling about something ... but often not much more than that. * sr.: will generally well foresee problems and potential problems, often/commonly well before they occur, and will generally work to avoid having problems/issues. When things go sideways, they're generally much more quick and efficient at recognizing it, knowing or figuring out exactly what the situation is, and how to efficiently correct the issue while minimizing negative impacts and resolution time. sr. will also figure out or be highly instrumental in figuring out and resolving the darn tough problems that nobody else can manage to figure out. E.g. few thousand failures daily among tens to hundreds of billions of events across many to 10s of TiB of data per day, I highly isolated that out and including all the needed relevant context when none of the developers or other sysadmins could. Likewise often highly well isolate relatively rare fast transient intermittent problems and get those problems nailed and corrected. Notice patterns others miss, leading to much faster resolution of problems and downtime. E.g. hardware problem - if I'd followed standard procedure and documentation, we would've been down >half day, I was able to get us back to nominal operation in well under 30 minutes, notably catching not only hardware diagnostics, but the meta-information of *how* they indicated, which pointed, along with some other evidence, to probable cause, used that to rectify the immediate issue to promptly resume normal operations. * sh\*t from shinola: * novice: will search (e.g. Google), will spend much time trying to figure out what information is good/useful, crud, poor, wrong, or "correct" but not a useful rabbit hole to go chasing down. * sr.: will generally quickly and well tell apart and sort out what information is more/most useful - vs. not, how credible/vetted, and not, be able to well test/evaluate/vet, and will be able to figure out which trails and branches are well worth following and may be quite useful and relevant, vs. those that won't be or are quite unlikely to yield useful information/results. * go search or look it up, vs. near encyclopedic knowledge of ... * novice: they won't know or won't be sure, they's search, look it up, read it, etc., hopefully test, etc. as appropriate * sr: much they'll already highly well know. Doesn't mean they don't look up, but when they do, it's typically double checking or confirming, or checking on some finer details, or looking up information about some significantly more obscure or complex issue/problem/challenge. So, while <(<) sr. will be looking up a lot 'o stuff on man pages, and maybe even trying to figure out what man page(s) to be looking the stuff up on and reading, sr. will be ... well, I had coworker that referred to me as "walking man page", as that coworker, and other coworkers, would often just ask me, rather than look it up on the man page - as they could generally get the information they wanted much more quickly, and generally down to whatever level of detail the wanted ... command, options, even more obscure options, alternative commands/approaches and various pros and cons ... yeah, I read *all* the UNIX man pages ... multiple sets in fact, ... and well retained most of the relevant information. * information sharing, transparency, etc.: * sr: will well document, share information, answer questions, train/mentor, etc. And if/when they make a mistake or do something less than optimally, it's not something they hide. They'll readily admit it, even showcase it, on how to better do/approach it, the hazards to watch out for, lessons learned, etc. * novice: they're generally still figurin' that out, sometimes they don't/won't ask for help/assistance when they should (and sure, sometimes they ask way too early when they should at least do some basic (re)searching and reading first), often they're not keen on letting it be known when they fscked up (hiding big booboos is generally a big no no and can end up being a bye bye sysadmin) (and mistakes will happen - even with sr. folks) or made an error ... or failing to appropriately ask when they're not (sufficiently) sure (depending upon context) ... either regarding what they're about to do ... or results of what they did. * top-to-bottom, depth and spread: * novice: will mostly know around some at least reasonable bit of CLI, and some reasonable bit of higher-level system concepts - notably at OS level * sr. will have much more comprehensive and deep knowledge, not only thoroughly on CLI and commands, shell(s), most or all utilities, various relevant programming languages, etc., but also hardware from bottom up, including electrical, electronics, machine, assembly, C (or other relevant language), and also higher levels, how applications use resources, what they serve, how, where, how they interact, lots of networking, security, how collections of systems interact, large and scalable designs, etc. * knowledge, abilities, skills * sr: generally knows the limits of their knowledge, abilities, skills, and will be humble - there's *always* somebody who knows more, and *always* opportunity to learn * novice: is generally still figuring that out And of course not all novices and sr.s particularly or precisely fit these patterns, but that's at least a relatively fair example or approximation thereof regarding the differences and types of differences one will generally see (and of course too there's quite a spread between ... at any given time, most are somewhere in those ranges between).