In today\u2019s fast-paced world, upskilling is essential for career growth. So why did I decide to enrol in foundational university courses at the age of 48? Learning has always been a challenging yet rewarding path for me. As the first in my family to pursue graduate education, I faced numerous hurdles. Starting my academic journey in pure mathematics in the early 90s during a national crisis, while also starting a family at a young age, presented significant challenges.<\/p>\n
Nevertheless, it is through continuous learning that I have gained professional expertise in three distinct fields: corporate finance and asset management, consulting, and now computer science. This enduring quest for knowledge has enabled me to build a fulfilling career, keeping me energised and always on the lookout for new projects and opportunities. This blog is more a personal reflection on my motivations and experiences than a detailed report on the Stanford Graduate Program in Computer\u00a0Science<\/a>.<\/p>\n Completing Stanford\u2019s introductory programming courses required approximately 1000 hours, 10 exams, 34 homework assignments, 40 sections, and numerous quizzes and concept\u00a0checks.<\/p>\n List of courses with languages and GNU tools\u00a0used:<\/p>\n CS106A Programming Methodology (Python);CS106B Programming Abstractions and Data Structures(C++);CS107 Computer System and Organisation (architecture x86\u201364, C, bash, emacs, gdb, valgrind);CS111 Operating Systems Principles (C, C++, bash, gdb, valgrind, calgrind);CS161 Design and Analysis of Algorithms (optional homework in C++ or\u00a0Python);<\/p>\n Modern university courses focus on systematically exposing students to substantial modules of information within a short time frame and assessing their understanding with high precision. During the program, I attended approximately 150 lectures. Some courses had substantial implementation requirements, necessitating significant programming efforts for homework assignments.<\/p>\n This is the third certificate in my educational journey at Stanford. The first was a professional certificate in \u201cArtificial Intelligence\u201d (2020), and the second was a graduate certificate in \u201cData, Models, and Optimization\u201d (2021). The distinction between professional and graduate certificates lies in the time commitment and structure of the learning process. A professional program can be viewed as Coursera+, offering high-quality content, access to university online infrastructure, minimal testing with flexible deadlines, and primarily automated code assessments.<\/p>\n The graduate program, on the other hand, involves studying alongside matriculated students, with identical homework, exams, and strict deadlines. This demands a higher level of commitment in terms of both time and financial investment. The course grades appear on the official transcript, providing a rigorous and comprehensive assessment of a student\u2019s knowledge.<\/p>\n One key insight I gained was how technology can break down reality into digital elements like pixels, packets, and tokens. The more we interact digitally, the easier we accept the substitution of the real world with digital surrogates. This blurring of reality extends to advanced applications like language models, showing how widespread digital transformation has\u00a0become.<\/p>\n The number and quality of tools available to aspiring programmers nowadays is impressive. For instance, debuggers help find bugs in code and encourage thoughtful analysis of code behaviour and logic. It\u2019s amazing how much information can be obtained from a debugger. In business or social interactions, it\u2019s often necessary to interpret facial expressions or contextual clues to understand others. Similarly, in programming, using a debugger can reveal hidden details in the code, underscoring the value of thorough information analysis. Writing tests before the main code, known as test-driven development, is another practice that seemed akin to Socratic questioning to\u00a0me.<\/p>\n Reflecting on William Blake\u2019s statement,<\/p>\n I must create a System, or be enslav\u2019d by another\u00a0Man\u2019s<\/p>\n during the program raised thought-provoking questions. In a world where systems define the objective reality, how should we approach them? Should we create our own<\/strong> systems or understand and deploy the existing ones? But if we rely on external systems, what happens to our ability to make choices? This contemplation prompts us to closely examine all systems, particularly IT, that shape our worldview.<\/p>\n The course on operating systems was truly fascinating. It\u2019s incredible to think about how a single application can run multiple times within an operating system. The concepts of multiprocessing and multithreading, where \u201cchildren\u201d can access the same file, are particularly intriguing. The idea that different processes can yield different results when copying from the same memory address due to physical and virtual memory is mind-boggling. I was also captivated by the race conditions, mutexes, concurrency, and atomic operations involved.<\/p>\n Understanding how context switching actually happens was a revelation. To fully comprehend these ideas, it was necessary for me to develop a profound knowledge of computer operations at the CPU level, encompassing assembly instructions. I recall my astonishment at observing how a primary execution register smoothly shifts between threads, maintaining its local variables and stack without disruption.<\/p>\n It\u2019s no surprise that courses on core computer architecture have remained relevant for 50 years, serving as a foundation for future projects. Additionally, when reading GNU documentation, it\u2019s often easy to discover that many new ideas in technology are actually old ideas. Therefore, studying pioneers like UNIX v.6 is not only of historical interest.<\/p>\n I was thrilled to take an optional course on algorithms while simultaneously reading Igor Manin\u2019s \u201cComputable-Non-Computable\u201d (Radio Publishing House, 1980). The book piqued my interest after I heard this anecdote:<\/p>\n When asked whether computer science is theoretical or practical, Manin\u2019s dual response was that it\u2019s either a theory of real<\/strong> reality or an experiment in Platonic<\/strong>\u00a0reality.<\/p>\n What\u2019s special about this book? It was among the first to discuss the relevance and possibility of quantum computing<\/a>. Three key elements are crucial for the adoption of quantum computers:<\/p>\n A mental model where the physical paradigm is the easiest path, similar to Von Neumann automata\u00a0(qubits)Technology to implement the\u00a0modelMathematics to prove correctness<\/p>\n I\u2019ve also pondered simpler things. Algorithms must be written efficiently, as anything non-polynomial is computationally infeasible when scaled. Conversely, using graphs allows for more meaningful processes to be abstracted from the real world compared to tables (vectors). It\u2019s surprising that many important graph algorithms can be computed in linear time. Additionally, it\u2019s fascinating how narratives can be described using directed acyclic graphs (DAGs). This brings me back to Jean Fran\u00e7ois Lyotard\u2019s<\/a> famous question:<\/p>\n Can one be educated by algorithms?<\/p>\n In the 21st century, the answer is yes. However, I would prefer hyper-graphs, even though I fully acknowledge that generalising the concept of directionality presents a challenge.<\/p>\n Coding in high-level languages is a rewarding experience. Before joining this graduate program, my programming experience was limited to Fortran, which Paul Graham compared to assembly with subroutines, and Python, where I developed code by using Stack Overflow and borrowing idioms from others, and a basic competences in MatLab. Systematic coding efforts during the program have led me to interesting linguistic discoveries. To illustrate, consider one of Manin\u2019s concepts:<\/p>\n the shift of meaning, from more or less explicit semantics of notations to the hidden semantics of algorithms transforming strings of symbols, was a key event in the process of algebra\u2019s birth<\/p>\n This is how it unfolded during my learning. The journey started with reviewers deducting points for style in your homework code (more details can be found in the second article about the educational process for the Stanford Graduate Program). I see this as a fair trade-off improving my code-writing skills. To minimise point deductions, I started maximising code reuse and incorporating abstraction, classes, and objects harmoniously. Soon I discovered design patterns that emerge as obvious best solution to the problem. For instance, the State (Variable) design pattern facilitates communication between two processes without manually monitoring all variables. The subsequent challenge involved coding the program\u2019s most complex required behaviour using the minimum number of lines. Sometimes it results in \u201cdense code,\u201d which, while reducing errors, can be harder to read or understand.<\/p>\n There\u2019s a growing awareness that humanity\u2019s dependence on current centralised systems may be nearing its conclusion.<\/a> It seems that we need to shift our focus back to individuals. However, according to Blake(!), individuals do not mesh well with systems. Therefore, in the new cycle, we must bet on communities instead. Systems will still execute, but they would not be the centralised monsters anymore. Whether this is a simplistic notion or a good insight will become clear in the coming years. However, if we examine the evolution of computer science, particularly in the industry, we may get a sense of where things are\u00a0headed.<\/p>\n Initially, in 70\u201380s operating systems were created with millions of lines of code. Much research was conducted on issues such as concurrency, race conditions, and deadlocks. Then, technology companies emerged, developing algorithms that physicists and mathematicians could not describe using formulas. Examples include Google\u2019s implementation of PageRank and recommender systems. Subsequently, operating systems transformed into browsers, and programmers began using SDKs like Angular Dart. These platforms fostered cooperation and interaction based on less formal rules than a fully coded information system could accommodate. Undoubtedly, systems development has become unbundled and decentralised. If user dissatisfaction continues to grow, the next step will likely involve the decentralisation of systems architecture and execution itself.<\/p>\nProgram description<\/h4>\n
What is a Graduate Certificate?<\/h4>\n
Insights from Stanford Computer Science\u00a0Journey<\/h3>\n
Digital Deconstruction<\/h4>\n
Tools of Enlightenment<\/h4>\n
Systems as Means of Communication<\/h4>\n
Operating Systems Course\u200a\u2014\u200aMind Blowing Experience<\/h4>\n
Algorithmic Wonders<\/h4>\n
Homo Algorithmus<\/h4>\n
Frontiers of System Centralisation<\/h4>\n
Learning<\/strong> Path: Cycles or\u00a0Spiral?<\/strong><\/h4>\n