Books made me an engineer

In retrospect, I was not a good engineer in my undergraduate days (1993-1997, more than 25 years ago). Though being in one of the best-privileged colleges in South Korea and even having good credits, I was not a productive engineer. I could follow courses; I could implement a simple microprocessor with VHDL and understand (and implement) the Red-black tree. However, I didn't have any idea of where I could use these things in the actual products. It was the 1990s, and it was the dawn of the software industry in Korea. It was when I was in my master's degree (1997-1998) that I could become an engineer; three books made me so.

1. Essential COM (Don Box / Addison-Wesley, 1997)

When I just entered graduate school for my master's degree, everyone should make presentations by turns. My first topic was Active X, which I chose by myself. Many people who know me (as an Apple zealot) wouldn't believe this, but I was a super Microsoft advocate then. Sun SPARC and SGI Indogo2 workstations were the symbols of the prestige schools and laboratories. However, as a young maverick with a callow ego, I thought everyone's computer (PC - Windows 95) should get more attention. I just heard that Active X is Microsoft's new technology, and that was the reason.

And, now I can tell I was totally ignorant of what I said at my first presentation. Active X was Microsoft's component software technology, but I couldn't even get what was the 'component' here. I heard that it was originated from COM (Component Object Model) and picked this book. I read it over and over, and I could tell what IUnknown, QueryInterface, and AddRef were. But I didn't know how they were made of, more specifically, where/how those resided/existed. I learned the compilers and operating systems in the coursework. But in those old days, we could hardly have real experiences with them; all were just in the text - incomplete, fragmentary knowledge. Scattered dots. This book was meaningful because it taught me there was something I didn't know; then, I met the second book.

2. Inside the C++ Object Model (Stanley B. Lippman / Addison-Wesley, 1996)

Now that I think about it, it was just an absolute coincidence - and great luck to me - to pick up this book at the college bookstore. I couldn't quite remember it, but it would be because of the work 'Object' in the title; I might think it would help me understand COM.

What is the Object? or OOP (Object Oriented Programming)? I could tell the four OOP principles: encapsulation, abstraction, inheritance, and polymorphism. However, this book made me realize that I had only known them theoretically (grammatically in C++). This book taught me how actually those principles were implemented. Especially, I was thrilled when I learned how vptr (virtual pointer) and vtable (virtual table) internally worked. Even now, I can't forget that time - the feeling that every scattered dot connected. After understanding the binary level, I could have concrete ideas about how components were implemented and integrated at every level. This is the book I can recommend to new engineers even these days.

3. Multithreading Applications in Win32: The Complete Guide to Threads (Jim Beveridge, Robert Wiener / Addison-Wesley, 1997)

The last book taught me the basics of the system/backend engineer. In 1998, I worked part-time on a game project, Lineage. Now, Lineage is the most successful game in the Korean game industry history. Still, at the time, there were only three developers: Jake, who developed all the code of Lineage at the time, Adam, who created all artworks, and me who was just a sub-programmer (and a GM). At the time, the Lineage server was implemented with Object-C on a Sun Solaris server and could only go through 300 concurrent users. Someday, I proposed to port the server with C++ on Windows NT; I couldn't provide any specific arguments, but it seemed apparent to me that Object-C couldn't be scalable. Jake didn't mention any specific to me, so I thought he just disregarded my opinion. But someday later, he showed me the first prototype of the C++ server and introduced this book to me.

The core idea of the Lineage C++ server was the I/O completion port and the thread pool, a feature of Windows NT. I was shocked by the fact that limiting the number of threads by pooling could improve the overall performance. The concept has become very common such as in kqueue and epoll now, but the book made me understand the basics of server resource management.

Those are the precious books that made me of this day. Although I was out of the engineer's path for a long time, the feeling has always been my precious: the feeling of connecting dots, the moment that fragmented things are connected through a line - the enhancement that I grok out something. A reminiscence exists at present.