I’ve been revising my Cisco Live session on IOS XE programmability, and it’s made me think about programming in general, and a particular idea I’ve been embarrassed to admit I loathe: Object Oriented Programming.
Some context: I started programming on the Apple II+ in BASIC, which shows my age. Back then programs were input with line numbers and program control was quite simple, consisting of GOTO and GOSUB statements that jumped around the lines of code. So, you might have something that looked like this:
10 INPUT "Would you like to [C]opy a File or [D]elete a file?"; A$
20 IF A$ = "C" THEN GOTO 100
30 IF A$ = "D" THEN GOTO 200
This was not really an elegant way to build programs, but it was fairly clear. Given that code was entered directly into the DOS CLI with only line-by-line editing functionality, it could certainly get a bit confusing what happened and where when you had a lot of branches in your code.
In college I took one programming course in Pascal. Pascal was similar in structure to C, just far more verbose. Using it required a shift to procedural-style thinking, and while I was able to get a lot of code to work in Pascal, my professor was always dinging me for style mistakes. I tended to revert to AppleSoft BASIC style coding, using global variables and not breaking things down into procedures/functions enough. (In Pascal, a procedure is simply a function that returns no value.) Over time I got used to the new way of thinking, and grew to appreciate it. BASIC just couldn’t scale, but Pascal could. I picked up C after college for fun, and then attempted C++, the object-oriented version of C. I found I had an intense dislike for shifting my programming paradigm yet again, and I felt that the code produced by Object Oriented Programming (OOP) was confusing and hard to read. At that point I was a full-time network engineer and left programming behind.
When I returned to Cisco in 2015, I was assigned to programmability and had to learn the basics of coding again. What I teach is really basic coding, scripting really, and I would have no idea how to build or contribute to a large project like many of those being done here at Cisco. I picked up Python, and I generally like it for scripting. However, Python has OO functionality, and I was once again annoyed by confusing OO code.
In case you’re not familiar with OOP, here’s how it works. Instead of writing down (quite intuitively) your program according to the operations it needs to perform, you create objects that have operations associated with them according to the type of object. An example in C-like pseudocode can help clarify:
rectangle_type: my_rect(20, 10)
rectangle_type: my_rect(20, 10)
Note that in OOP, we create an object of type “rectangle_type” and then is has certain attributes associated with it, including functions. In the procedural example, we just create a variable and pass it to a function which is not in any way associated to the variable we created.
The problem is, this is counter-intuitive. Procedural programming follows a logical and clear flow. It’s easy to read. It doesn’t have complex class inheritance issues. It’s just far easier to work with.
I was always ashamed to say this, as I’m more of a scripter than a coder, and a dabbler in the world of programming. But recently I came across a collection of quotes from people who really do know what they are talking about, and I see many people agree with me.
How should a network engineer, programming neophyte approach this? My advice is this: Learn functional/procedural style programming first. Avoid any course that moves quickly into OOP.
That said, you’ll unfortunately need to learn the fundamentals of OOP. That’s because many, if not most Python libraries you’ll be using are object oriented. Even built in Python data-types like strings have a number of OO functions associated with them. (Want to make a string called “name” lower-case? Call “name.lower()”) You’ll at least need to understand how to invoke a function associate with a particular object class.
Meanwhile I’ve been programming in AppleSoft quite a bit in my Apple II emulator, and the GOTO’s are so refreshing!
Hey Jeff, great article and absolutely reflects my fear of Programming and everything to do with OOP. I always felt very comfortable coding in C and Java until functions, classes, and references across packages and files started. I would definitely love to dive more into Programmability from a Network Engineer POV and get my hands on with some Python automating tasks on DNAC.