Teaching

I have been teaching the following software development and architecture courses. Prerequisites for each course are listed, along with the books I suggest as supplementary materials. I prefer to teach through hands-on coding, discussing the pros and cons of every design decision with the participants.

YZV445 - AI Practice (Agentic AI) (2026 - ...)

Agentic AI systems represent the next frontier of applied artificial intelligence, where models don't just respond but plan, act, and collaborate autonomously. This graduate-level lecture covers the foundations and practical applications of agentic AI, including agentic design patterns, planning–acting loops, tool use, and multi-agent workflows. The course has a strong emphasis on hands-on practice, where participants build real agentic pipelines from the ground up.

Course Outline:
  • Introduction to Agentic AI: From LLMs to Autonomous Agents
  • Agentic Design Patterns: Router, PromptChain, Reflection, Tool Use, Planning, Consistency, Inverse Prompting, Multi-Agent
  • Planning & Acting Loops: ReAct, Chain-of-Thought, Graph-of-Thought, Tree-of-Thought
  • Tool Use: Function Calling, External APIs, Code Execution
  • Retrieval-Augmented Generation (RAG)
  • Multi-Agent Workflows: Orchestration and Collaboration
  • Hands-on: Building Agentic Pipelines with LangChain and Google ADK
  • Istanbul Technical University – Artificial Intelligence and Data Engineering Department – 2026–Present.

Course designed by Gökhan Ercan.

CSE112 - Object Oriented Programming (2018)

Prerequisites: Programming Java Basics
(From the course's original syllabus.)
The objective of this course is to introduce the concepts of object oriented thinking, design, and programming on Java language platform. Upon successful completion of the course, the students will be able to:
  • Explain the object oriented approach in programming
  • Use an object oriented programming language Java, and associated class libraries, to write and test programs
  • Develop UML based designs using the concepts of data encapsulation, inheritance, and polymorphism to solve real world problems
  • Implement UML based designs (based on class diagrams) for problems displaying some architectural complexity, and considerable inter-class communications
  • Use IDE(s) to design, implement, debug and execute object-oriented applications.
  • Işık University - Computer Engineering - Summer 2018 students, click here to download course's syllabus.

Test Driven Development & Unit Testing Patterns (2014 - 2022)

Prerequisites: Object Oriented Programming & Design Patterns
Delivering high-quality production code requires well-organized unit tests with enough coverage. However, paradoxically, proper unit testing requires well-designed software that flawlessly handles dependencies of inner components. TDD methodology addresses the problem by offering development teams to follow a straightforward process called red-green-refactor. When developers clearly define requirements before implementing them, they can isolate test cases easily and introduce lesser bugs. This course focuses on patterns, practices, and processes for developing high-quality software with unit tests while making in-depth analyses of mocking/stubbing, dependency injection, and testing tools. –Gökhan

"If debugging is the process of removing software bugs, then programming must be the process of putting them in."

Edsger Dijkstra
    Course Outline:
  • Introduction to Testing
  • Types of Testing
  • Unit Testing vs. Integration Testing
  • Unit Testing Tools
  • TDD Methodology, Red-Green-Refactor Cycle, Being Agile
  • TDD and Refactoring
  • OOP Quick Review
  • Breaking Dependencies with Dependency Injection (DI)
  • Test Doubles (Mocks, Stubs) - Isolation Frameworks
  • Value-based vs. State-based vs. Interaction Testing
  • Testable Software Design and Architecture
  • Avoiding Anti-patterns: Statics, Singletons, etc.
  • Test Code Organization and Quality
  • Code Coverage
  • Behavioral Driven Design (BDD)
  • Continious Integration (CI) and Continious Delivery (CD)

Course designed by Gökhan Ercan.

Enterprise Design Patterns & Architectures (2013 - 2022)

Prerequisites: Object Oriented Programming & Design Patterns
This course is designed to help teams develop enterprise software development frameworks to support multiple applications and components within the organization. Enterprise developers should quickly satisfy high-quality standards while dealing with highly complex problem domains, services, and user interfaces. Enterprise-level design patterns and practices cover developing reusable, maintainable, and extensible components/layers such as data access, ORM, service communication, DI containers, configuration management, logging, exception handling, caching, security, user interfaces, and so on. This course employs a data-centric approach to enterprise development where most topics are based on Martin Fowler's famous "Patterns of Enterprise Application Architecture" (EAPP) book. Throughout the course, even the most complex foundational layers will be developed from scratch, such as Data Mapping, Dynamic Proxy, Unit of Work, and MVP.
    Course Outline
  • Domain Modeling: Anemic Model, POCO, Domain Model, DDD, CRUD Entity Model etc.
  • Crosscutting Concerns: Logging, Caching, Configuration, Authentication, Authorizarion, Security etc.
  • Developing Enterprise Framework: Coupling, Versioning, DSLs, Metadata Management, Principles of Packaging etc.
  • Service Layer: Transaction Script Model, Web Services, Facade, REST API, Transactions, Repository, DTO etc.
  • User Interface Layer: Screen Generation, Multi-lingual, Ambient Context, MVC, MVP, MVVM etc.
  • Unit Testing: Testable Business Layer, Tools, Managing Dependencies, Stubbing/Mocking, BDD, Anti-patterns etc.

Object Oriented Programming & Design Patterns (2012 - 2022)

Prerequisites: Programming Data Structures
This course covers advanced object-oriented programming techniques and design patterns essential in developing reusable and extensible libraries. In a modern development world, every team should agree on the fundamentals of the object-oriented theory regardless of the platforms they use. The course iterates through every GOF design patterns after making an in-depth analysis of popular SOLID principles. –Gökhan



    Course Outline
  • Object-oriented Review
  • SOLID Principles: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
  • Design Patterns: All 23 GOF design patterns by real-world examples.

Advanced ASP.NET Development (2010 - 2012)

Prerequisites: Programming Web Development
The course covers advanced methods for developing enterprise-level web applications and reusable web components. Instead of explaining the usage of existing components and structures of the ASP.NET system, it aims at dissecting underlying structures of ASP.NET system such as application lifecycle, page lifecycle, web control hierarchy, HTTP modules/handlers etc, in order to give participants courage to develop their own reusable components from scratch or extending existing ones. Furthermore, it searches for solutions on enterprise level non-functional requirements such as security, caching, configuration management and performance monitoring. –Gökhan

    Course Outline
  • Application Lifecycle: AppDomains, HttpContext, HttpModules, HttpHandlers, Config inheritance, Request validation, IIS Modes etc.
  • Page Lifecycle: Postback, Viewstate, UrlRewriting, WebForm Events, Databinding etc.
  • Web Controls: Dynamic controls, Custom controls, TemplateField, Business controls, Attributes, Viewstate encryption etc.
  • Localization/Globalization: Culture, UICulture, Culture events, Ambient context, Global resources etc.
  • Session Management: State servers, Webfarms, Session events, Custom session module, Monitoring etc.
  • Caching: Output Caching, Data caching, Cache depedency, Substitution, Custom caching, Async page etc.
  • Web Application Security:URL hashing, OWASP list, Sql injection, XSS attacks, Session hijacking etc.

Developing .NET Applications with C# (2010 - 2012)

Course covers basic concepts required for developing web applications with .NET Framework, ASP.NET and MSSQL Server technologies. Some of the main components of the course are:
  • Object Oriented Programming Basics: static vs. instance, constructors, interfaces, inheritance, events, overriding, overloading etc.
  • .NET Basics: ref types, value types, arrays, collections, indexers, attributes, convertions, boxing, generics, linq, etc.
  • SQL Server: Relational database design, ADO.NET objects, stored procedures, indexes, queries, views, reporting etc,
  • ASP.NET: state management, web controls, data binding, postback, caching, http handlers, http modules, ajax, javascript etc.

Gökhan Ercan See it on X
The best programmers today will be the next generation of product managers.

Companies should stop this non-technical “Product Owner + Scrum Master” nonsense and start empowering their strongest engineers to own, prioritize, and deliver the backlog.
t.co/qGDM3zBUaQ
Oct 3, 2026
Gökhan Ercan See it on X
A pleasure to teach Agentic AI this term at Istanbul Technical University.

We covered 17 agentic patterns: Agentic RAG, ReAct, Memory, Guardrails, multi-agent, Graph-of-Thoughts. Best part: seeing 40 student projects move from "use an LLM" to "design an agent."
Jun 25, 2026
Gökhan Ercan See it on X
RT @dhh: Microservices is the software industry’s most successful confidence scam. It convinces small teams that they are “thinking big” while systematically destroying their ability to move at all. It flatters ambition by weaponizing insecurity: if you’re not running a constellation of services, are you even a real company? Never mind that this architecture was invented to cope with organizational dysfunction at planetary scale. Now it’s being prescribed to teams that still share a Slack channel and a lunch table.

Small teams run on shared context. That is their superpower. Everyone can reason end-to-end. Everyone can change anything. Microservices vaporize that advantage on contact. They replace shared understanding with distributed ignorance. No one owns the whole anymore. Everyone owns a shard. The system becomes something that merely happens to the team, rather than something the team actively understands. This isn’t sophistication. It’s abdication.

Then comes the operational farce. Each service demands its own pipeline, secrets, alerts, metrics, dashboards, permissions, backups, and rituals of appeasement. You don’t “deploy” anymore—you synchronize a fleet. One bug now requires a multi-service autopsy. A feature release becomes a coordination exercise across artificial borders you invented for no reason. You didn’t simplify your system. You shattered it and called the debris “architecture.”

Microservices also lock incompetence in amber. You are forced to define APIs before you understand your own business. Guesses become contracts. Bad ideas become permanent dependencies. Every early mistake metastasizes through the network. In a monolith, wrong thinking is corrected with a refactor. In microservices, wrong thinking becomes infrastructure. You don’t just regret it—you host it, version it, and monitor it.

The claim that monoliths don’t scale is one of the dumbest lies in modern engineering folklore. What doesn’t scale is chaos. What doesn’t scale is process cosplay. What doesn’t scale is pretending you’re Netflix while shipping a glorified CRUD app. Monoliths scale just fine when teams have discipline, tests, and restraint. But restraint isn’t fashionable, and boring doesn’t make conference talks.

Microservices for small teams is not a technical mistake—it is a philosophical failure. It announces, loudly, that the team does not trust itself to understand its own system. It replaces accountability with protocol and momentum with middleware. You don’t get “future proofing.” You get permanent drag. And by the time you finally earn the scale that might justify this circus, your speed, your clarity, and your product instincts will already be gone.
Dec 12, 2025
Gökhan Ercan See it on X
RT @ealpaydin: "Scientists undertake basic research to generate new knowledge with no specific end goal in mind. Applied research is different in that it aims to find solutions to real-world problems." t.co/3zQAg87EUy
Oct 5, 2025
Gökhan Ercan See it on X
RT @rohanpaul_ai: "Hallucinations need not be mysterious—they originate simply as errors in binary classification.

If incorrect statements cannot be distinguished from facts, then hallucinations in pretrained language models will arise through natural statistical pressures."

- OpenAI Paper
Sep 6, 2025
Gökhan Ercan See it on X
I really liked this OS analogy for LLMs. Strongly encourage watching the full speech by Karpathy. t.co/df0wB6JqnU
Aug 23, 2025