Todd A. Martin, IT Specialist Consulting

If you always do what you've always done, you'll always get what you always got. Change provides the means to conquer competition.
Home     Employment History     Contact Us     Technical Stories     Sample Client Application     Todd's Biography     Useful Technology Sites      
Story No. 1     Story No. 2      

  Technical Story 


 The Mad Dinosaurs 

 

 

 
 
I will start with a new cliché: 
 
Back in the day, when it came to Client/Server and RDMS Database technologies, I had the fortune of being involved with a huge Mainframe to Client/Server migration project with a large Manufacturing firm in Canada. This was to become the largest Client/Server production environment in North America at the time. See also: http://www.sygration.com/ClientServerUnderGlass.html .
 
This is story as much about people as it is about the technologies.
 
This company was "bleeding edge" when it came to technologies, and thanks to their talented and dedcated people they always pulled it off. The desktop population was approximately 4,000 PCs. The migration also came with an attempt to rollout newer PCs. The existing client base was Compaq 486DX4 100's and the new client base with migration was Pentium PCs.
 
The challenge back then was with the Microsoft Windows 3.1 Operating system that actually sat on DOS 6.22. The 'baptism by fire' came with getting the middleware between the 16 bit operating system to effectively communicate with an early 32-bit Client/Server version of Oracle and infant versions of HP/Unix (midrange).
 

 
Oracle's middleware at that time was called SQL*Net version 2.1.xx.xx.a (the long version suffix allowed Oracle to track and qualify their daily bug fix features releases for their somewhat limited middleware).
 
In retrospect, we did all the right things possible for that time in I.T. history. As the Desktop Team was building an HP guided C.O.E. (Core Operating Environment) for the desktop, the Database Team and Mainframe Teams were migrating data from the IBM MVS Mainframes, and the Application Developers were continuously introducing application features to their Power Builder code.
 
I was a technical liaison between the Desktop Team, the Database Team, and the Application Developers.
 
Thus, I was in several middles.
Don't get me wrong, I enjoyed the challenge.
 
The trick was continuously and accurately modifying the 'good old' desktop configuration files (oracle.ini, sqlnet.ora, tnsnames.ora, win.ini) etc., adjusting the infrastructure, and keeping up with all the production changes to the databases, the applications and the desktop (not necessarily in that order).
 
Of course we were also continuously testing in the Labs and performing UAT (User Acceptance Testing) the whole time. One of the things we soon discovered was the inability to quickly and accurately "push" the configuration changes to the desktop. The server changes were pretty much centralized and did not come as a huge challenge. We had implemented change control to roll out each of the Development changes to track in case we needed to reverse/adjust any configuration changes.
 
At that time we were running Novell as our file and print services Network OS. I had been doing research on the method of 'centrally' containing desktop configurations passed through a Netware login script on a Novell Server for the desktop. I also had researched and had been performing testing on having the client middleware (SQL*Net and the complete Oracle client) housed on Novell Servers.
 
This proved to be very effective and worked.
 
We were also embarking on a relatively new technology; namely: Microsoft's System Management Server (SMS) version 1.1. This ESD (Electronic Software Distribution) system was to manage the 4,000+ client base. 
We had been using Novell login scripts to push down "package" installations utilizing chained batch programs. The SMS solution would provide a 'Central Management' console and a offer a more complete packaging, distribution, monitoring and support solution.
Security on the client was not an issue with the Windows 3.1 Operating System but we knew it would become an issue with the upcoming planned implementation of Microsoft Windows NT 4.0 and/or Windows 2000 Professional.
 
Near the very end of the UAT and QA testing we ran into a severe road block in the critical path of the Client/Server project. Intermittent Oracle errors were occurring after we had already stepped through and resolved many such Oracle errors before. However, this set of errors were different and were a real problem because we were less than 1 week away from performing the 'Turn Key' migration from the Mainframe applications and to the Client/Server environment . 
 
We could not consistently repeat the errors, nor could we pinpoint what had changed (even after studying all the related Change Controls). I went back into the Computer Support test lab and worked with several Teams (Application Developers, Database Administrators, Midrange Server Group and Computer Support)  to resolve the problem. Soon we discovered that it was the middleware (Oracle's SQL*Net) that seemed to be responsible for the errors.
 
This was now my task to resolve. I was solely accountable for the solution. I was also under great pressure from the CIO and the Board of Directors to resolve the problem. The reasons for the pressure are obvious but it also would incur great unanticipated expenses to continue and renew the costly leases for the IBM Mainframe environment (hardware and operating environments).
 
After several meetings with Senior Management, I was back in the lab and began to utilize the Oracle logging and tracing utilities that were installed with the middleware (SQL*Net) to attempt to pinpoint the issue. Continuous calls and onsite support from Oracle and Microsoft were insightful but did not solve the issue.
 
Quickly I discovered that when I activated logging and tracing to debug the middleware components the errors ceased to occur. The log and trace files were also clear of error and failures. An end user (a great guy who went by the nickname of "Doc"; partially due to the fact that he was very computer literate) quickly coined my new nickname of "The Professor".
 
The Bottom Line:
 
We determined that the problem was the new client hardware being rolled into the test Client/Server environment, i.e. the Pentium PCs.
 

 
The majority of the Power Builder application code and infrastructure testing was performed using the 486 base (early and most of the way into the testing). Introduction of the new client platform was causing the Oracle and midrange environment to "overload" and fail on SQL requests from the applications. This was especially seen when more and more Pentiums were introduced and actively connected to the new Client/Server environment. 
 
We determined that there was insufficient time to dig into altering and retesting the application code, nor was there time to somehow adjust the Oracle / HP-UX Midrange environment; too much testing had already been performed to this point to go back to the drawing board in that arena.
 
Therefore, I recommended that we leave logging and tracing on for the production roll out. By adjusting the oracle.ini and sqlnet.ora etc. configurations on the Novell servers we accomplished our goal on time and under extended budget.
All log files were written to a common area on the Novell Servers so as to not cause 'bandwidth' issues with the client. We cleared the log and trace files off the Novell Servers continuously; since they were meaningless and just taking space.
 
By the way, we decided to include client PC hardware changes into the Change Management process from that point forward.
 
Why angry dinosaurs?
 
Well, the new plan with respect to populating real time manufacturing production data remained with the Mainframe environment. Instead of a goal to migrate off of 90% of the mainframe population, the corporation decided to maintain 30% of the Mainframe space.
 
The Mainframes were back in the equation and they were angry (i.e. the people that maintained them were angry). We still needed them, and they knew it from the start.
 
Bleeding edge?      Yep.
 
NEXT, we had to migrate from Novell to Microsoft ; and implement Microsoft Systems Mangement Server. See the next story.
 
 
The End.