Below is a life lesson from when I was a junior programmer. I've shared it many times in various contexts when I mentored people. Some of you have undoubtedly seen this post before.
When I started with IBM in the early 80s, we worked on mainframes, and submitted batch jobs for processing, and used a third party tool called SDSF to see the results online within minutes; this being an improvement over waiting hours for the results to print and be delivered to our door.
Despite working in teams, SDSF only allowed us to see our own jobs. Supervisors (think: root) could see other people's jobs, but we weren't supervisors.
Internally, SDSF needed to access controlled data (called spool, something you still see in Unix based operating systems today) to operate, so if you weren't a supervisor, it would go into supervisor mode, extract the data it needed, and then return back to normal mode. This was done via a small routine and an installed SVC. The small routine called the SVC, did what it was supposed to do, and then called the SVC again. This routine was in protected memory.
The SVC verified that it was called from SDSF routine, and then toggled the supervisor state.
While I couldn't change any of this code, this was the days of assembly language programming and I wrote a program that would locate the SDSF routine but instead of calling it from the top, it would call it from just before the end, where it called the SVC and promptly returned.
I was now in supervisor mode. Adding a call to the main entry point of SDSF, and I now had a program that would allow me to see the output of jobs that my teammates had submitted.
I called this program SNOOPY. I shared it with others.
Shortly thereafter, I was called into the Vice President's office. I was understandably scared. He immediately set my mind at ease, and left me with two (on the surface, contradictory) messages:
If you don't get your hands slapped at least twice a year, you aren't pushing the boundaries hard enough.
Don't do it again.