This course is about programming and artificial intelligence. Depending on what school you're at, that could mean robots, neural networks, chess playing, etc.

At this school, this course is about

• designing and implementing intelligent components for interactive distributed computational media
• developing tools for authoring the knowledge needed by such systems
• doing it all with maintainable code

In particular, the main topic areas of this course are

• symbolic knowledge representation techniques using Common Lisp
• software engineering

Symbolic Knowledge Representation

This will include

• using frames to represent real world concepts
• organizing those frames into taxonomic hierarchies
• frame and pattern-based inferencing

Software Engineering

Software engineering studies and manipulates the software development process. Programming is just one small part of that process:

• Before programming, there's requirements gathering and design.
• During programming, there's prototyping and usability testing.
• After programming, there's validation, deployment, maintenance, extension, and, eventually, replacement.

This is a course on programming, not the entire development process, but it's about programming as a part of this process. This is not a course about throw-away code. Your coding will be evaluated on how well it supports testing and validation, team development, maintenance, and extension.

There are three fundamental criteria by which code is measured:

• correctness-- does the code do what it's supposed to?
• efficiency -- does the code run fast enough?
• clarity -- is the code easy to understand?

For this class, the most important feature of your code is clarity.

• If code is clear but buggy, it can be corrected.
• If code is clear but slow, it can be optimized.

Scaling Up

Large knowledge-based systems need lots of knowledge. That means you need to be able to build knowledge-management tools that many people can use to enter and manage large bodies of knowledge.

This class will discuss the following techniques for knowledge-management:

• domain-specific mini-languages (macros, patterns, rules)
• knowledge management interfaces
• knowledge debuggers

Large knowledge-based systems also need to work in a timely fashion. As knowledge bases get large, the simple approaches become too slow for practical use.

Speeding Up

This class will discuss the following techniques for speeding up knowledge-based systems:

• discrimination trees
• pattern and rule compilers

Sending out

Delivered knowledge-based systems have to be maintainable, robust, and accessible to users.

Robustness means (1) the code as delivered works as promised, over a wide variety of situations, and (2) continues to work as promised when changed.

All systems have to be changed, but change is especially rapid and dramatic in knowledge-based systems, which are often the first of their kind in some application area.

The problem is ensuring the changes don't do more harm than good.

This class will discuss the following techniques for maintaining correctness under constant change are:

• test suites and test suite applies
• coding for testing

Comments? Send me email.