View and download the Syllabus Document in pdf for Georgetown Policies and Student Resources.

Course Format and Syllabus Design

The course will be conducted as a seminar and requires each student’s direct participation in the learning objectives in each week’s class discussions. The course has a dedicated website designed by the professor. The web syllabus provides a detailed week-by-week "learning map" with links to weekly readings (in a shared Google Drive folder). Each syllabus unit is designed as a building block in the interdisciplinary learning path of the seminar.

To facilitate learning, students will write short essays each week based on the readings and topics for that week. Your short essay must demonstrate that you've done the readings, and can comment on and pose questions about what you find to be the main points. At first, you will have many questions as everyone in the class begins learning new concepts to work with and working toward better technical knowledge in how the concepts in the course apply to computer systems, code, and digital media. Try to apply some of the main concepts and approaches in each week’s unit to examples and cases that you can interpreter in a new way. Students will also work in groups for in-class exercises and for collaborative presentations.

Students will participate in the course both in classroom discussion and with a suite of Web-based online learning platforms and e-text resources:

(1) A custom-designed Website created by the professor for the syllabus, links to readings, and weekly assignments:https://irvine.georgetown.domains/711/

(2) An e-text course library and access to shared Google Docs: most readings (and research resources) will be available in pdf format in a shared Google Drive folder prepared by the professor. Students may also create and contribute to shared, annotatable Google Docs for certain assignments and dialogue (both during synchronous online class-time, and working on group projects outside of class-times).

(3) Zoom video conferencing and virtual office hours. See: Students Guide for Using Zoom.

Grades:

Grades will be based on:

(1) Class Participation (50% of grade in two components): Weekly short writing assignments (in the course Canvas Discussion module) and participation in class discussions (25%). Collaborative group projects on topics in the syllabus (to be assigned) to be posted in the Canvas Discussion module and presented for discussion in class (25%).

Important: Weekly short writing assignments must be posted at least 6 hours before each class day. Everyone must commit to reading each other's writing before class to enable us to have a better-informed discussion in class.

(2) A final "Capstone" research project written as a rich media essay or a creative application of concepts developed in the course (50% of grade). Due date: 7 days after last day class.

Final projects will be posted on the course Canvas Discussion module, but you can also develop you project on another platform (Google docs, you own website, etc) and link to it in a Canvas discussion post for Final Projects. Your research essay can be used as part of your "digital portfolio" for your use in resumes, job applications, or further graduate research.

Professor's Office Hours and Virtual Meetings
Before and after class, and by appointment. I will announce a virtual office hours schedule in the second week of classes.

Professor's Contact Email: Martin.Irvine@georgetown.edu

Required:

• Peter J. Denning and Craig H. Martell. Great Principles of Computing. Cambridge, MA: The MIT Press, 2015.

Recommended:

• Luciano Floridi, Information: A Very Short Introduction. Oxford, UK: Oxford University Press, 2010. ISBN: 0745645720James Gleick, The Information: A History, a Theory, a Flood. New York, NY: Pantheon, 2011.
• Janet H. Murray, Inventing the Medium: Principles of Interaction Design as a Cultural Practice. Cambridge, MA: MIT Press, 2012.

Links to Online E-Text Library and University Resources

• Link to shared Google Drive folder for weekly readings (Georgetown students access only)
• Directory of Drive folders for all topics in the Etext Library (for your own reading and research)
  • You can do a keyword search of all documents in the Etext Library ("Search in Drive").
• Georgetown Library Main Page (click on "Journals" tab to search for Journals)

A Note on Readings in the Course

• I have written several introductions to the course units so that students will have a framework for understanding the interdisciplinary sources of ideas and methods for each topic. These introductions are drafts of chapters of a book that I am writing for students, and are based on my 25 years of research and teaching. Please give me your honest feedback on what works and what doesn't, what needs more clarification or more examples. There are no textbooks for the "big picture" interdisciplinary approach that we we do in CCT, so we have to make our own.

Professor Irvine's Introductory Video Series: Key Concepts in Technology

• I produced these videos for an earlier course, CCTP-798, Key Concepts in Technology. The basic background in these videos is relevant for topics in this course, and for your general learning in CCT. (They are short, mostly ~ 6-10 mins each. Note: the Week numbers don't correspond to the weeks in this course.)
• Key Concepts YouTube Playlist (I will link some in specific weeks of the syllabus).

Course Introduction: Requirements and Expectations

• View and download the Syllabus document in pdf:
  Course description, complete information on requirements, participation, grading, learning objectives, Georgetown Policies, and student resources.
• We will discuss further in class, and you can ask questions about anything.

Personal Introduction: My Background (pdf)

Using Research Tools for this Course (and beyond)

• Required: Learn how to use Zotero for managing bibliography and data for references and footnotes.
  • Directions and link to app, Georgetown Library (click open the "Zotero" tab).
  • You can export and cut and paste your references into writing assignments for this course, and all your courses and professional writing.
• Required: Learn how to use Georgetown Library Research Resources
  • Georgetown Library Main Search Page (all books, periodicals, media, databases)
  • Click on the "Journals" tab to search for journals by title.
• Prof. Irvine's e-Text Library for Students (Shared Googled Drive; GU login required):
• Readings for CCT 711
• Semiotics Library: Background and primary sources
• Computing Library: Backgrounds, history, and theory
• Information Theory Library
• Linguistics and Philosophy of Language
• Computational Linguistics, Natural Language Processing, and Computation
• Browse the whole Student Library (shared Drive folder) for readings and other research materials you can use in this course (and beyond)

Required Weekly Writing for Class: Canvas Discussion module for course

• Read the Instructions for your weekly writing assignment (read before posting!)

First Day: Introductory Presentation and Discussion (Prof. Irvine)

• Introductory Presentation (Google slides)
• Open Discussion, Q&A about the course.

Readings (read in this order:)

• Prof. Irvine, Personal Introduction and Background.
• Prof. Irvine, Introduction to the Course: Background on our Interdisciplinary Framework and Key Concepts [print for further reference]
  • Don't worry if many of the concepts and topics are new to you, and not understandable yet. We will discuss everything in class, and in a few weeks you will be learning how all the ideas connect, step by step.
• Peter Denning and Craig Martell, Great Principles of Computing (pdf). Read the preface and Introduction (xll-18).
  • Although this introduction focuses on the development of computer science as a discipline and on the industries and sciences that have formed around computing, Denning is very much a "history of ideas" thinker and is also widely known for his writings on design and computational thinking. This is a great book for CCT students; read it throughout the course.
• Prof. Irvine, Introducing Key Terms and Concepts: Code, Signs, Symbols.
  [Print out. Read for discussion in class.]
• A First Look at Recent Definitions and Conceptions of Computing (pdf).
• Short text excerpts by leading thinkers in computer science on the history of ideas about symbolic systems and computing.
• Think over these brief definitions, and reflect on these texts with the other background readings for this week.

Discussion and "workshop" in class this week:

• We will have an open seminar style discussion in class this week, and also a "workshop" where you will be able to practice some coding concepts. Read the background texts for the key terms and concepts, and make notes on questions and any "aha" moments in your thinking.

Writing assignment (Canvas Discussion module)

• Read the general "Weekly Writing Instructions" first. Important: We are using the discussion module in Canvas for your discussion of main points and questions in each week's readings and topics. You're not doing a "blog" post.
• Even though many of the concepts and approaches in the readings are probably new for you, discuss two of the key terms and concepts, and examples of how you can apply to understanding or explaining what we do in computing and code. Ask questions that you would like to have discussed in class. We will work through the backgrounds in class, and apply the ideas to examples and cases that interest you.

Readings & Video

• Prof. Irvine, "Symbolic Cognition and Cognitive Technologies" (Video, from Key Concepts in Technology) [This is a video that I produced for earlier course, and introduces the "big picture" view of symbolic thought and computing that we are studying this week.]
• Prof. Irvine, "Introduction to the Human Symbolic Capacity, Symbol Systems, and Technologies." [Read first for the conceptual framework for this week; print out for reference.]
• Thinking in Symbols (Video Documentary, American Museum of Natural History)
  • See also the Archaeology documentary video on the findings in South Africa, which allow us to date human abstract symbolic thought to at least 100,000 years ago.
  • Note: From the earliest surviving use of symbolic artefacts to the bits and bytes and screens in today's computing technology, (1) symbols require physical, perceptible form, (2) symbols come in systems with rules and conventions for interpretation understood by a community, through which meanings, intentions, and values are encoded and decoded, and (3) symbols are based on replicable patterns.
• Kate Wong, “The Morning of the Modern Mind: Symbolic Culture.” Scientific American 292, no. 6 (June 2005): 86-95.
  • A short accessible article on the recent state of research on the origins of human symbolic culture and the relation between symbolic thought, tool making, and technologies. Archaeological findings in the video documentary above are discussed in this article.
• Michael Cole, "On Cultural Artifacts," From Cultural Psychology. Cambridge, MA: Harvard University Press, 1996. Short excerpts.
  • Background: A good summary of cognitive psychology research on cultural artefacts (human-designed and made "technologies" that support communication, cultural meaning, and symbolic thought). Embracing views also shared in anthropology, Cole provides a descriptive model of the human artefact that opens up an understanding of a long continuum of cognitive artefacts in human social history. This view allows to see the implications of our longer history of using culturally adopted kinds writing surfaces (cave walls, clay, wood, parchment, paper, pixel screens), with technologies developed for inscribing writing and imposing images, and the more recent history of our technical media for representing, storing, and transmitting a symbolic system. (Note: these cultural facts unite European and Asian cultural history in a common human capability). Further, while tools are also artefacts (and only humans make tools to make other tools), we have a class of artefacts that are not simply instrumental (that is, used as tools to do something), but are designed to support human cognition (thought, conceptualization, symbolic expression) and to mediate (provide a material medium for) representing and transmitting cultural meanings in physical forms. This school of thought provided important concepts for Human-Computer Interaction (HCI) design theory in the 1960s-2000s. Computer interfaces are designs for using cognitive-symbolic artefacts in a specific technical design.
• Video: A Brief History of Number Systems (TED-ed, Math in Real Life series)
  • This short video provides the background on our decimal (base 10) numerals (number symbols).

Prof. Irvine, (Slides): "Introduction: The Human Symbolic Capacity, Language, Symbols, Artefacts, Technologies" (Part 1) (for discussion in class and study on your own)

Writing assignment (Canvas Discussion module)

• Discuss one or two discoveries that you made when you thought about the research and interdisciplinary background in this weeks readings and video lessons. Did you have any "aha!" moments, when some connections became clearer? Were you able to understand how and why our modern "symbolic technologies" (computer systems, digital data, networks) are part of longer continuum of human symbolic thought and the way we use, think in, and communicate with signs and symbol systems? This background will be completely new for you, so will have many questions: what would you like to discuss further in class?

Readings

• Prof. Irvine, "Introduction to Peirce's Semiotic Theory for Studying Computing Systems as Semiotic Systems."
  • We will work through the main concepts outlined here over several weeks. I don't expect the concepts to be understandable at first; it's hard work, but working out the ideas for yourself really pays off. Don't worry; I will explain things step by step.
• Winfried Nöth, “Human Communication from the Semiotic Perspective” (excerpt). From Theories of Information, Communication and Knowledge: A Multidisciplinary Approach, ed. Fidelia Ibekwe-SanJuan and Thomas M. Dousa. Dordrecht; New York: Springer, 2013: 97–119.
  • This is an approachable overview of how Peirce's key concepts apply to explaining communication as a semiotic process. We will go further and show how semiotic theory explains all forms of interpretation and computation.

Presentation:
Prof. Irvine, Intro Peirce's Semeiotic and Computing: Peirce 1.0

• We will go over these concepts in class; you can also study the presentation on your own.

Writing assignment (Canvas Discussion module):

• This is a fun exercise for becoming aware of a “semiotic process” and the way we use tokens and types of symbolic forms in an important kind of interpretation process -- translation. Go very slowly with your actions in the instructions below, and describe as many steps as you can by using the terms and concepts in the readings. (Next week, you will learn about language structures with an introduction to Natural Language Processing [NLP} in computing.)
• Background for the assignment: Peirce observed that the "meaning" of any set of signs is represented in the further signs it can be "translated into." Updating his terms a little for today, we can say that the interpreted meanings of {symbol set₁} take the form of "outputs" from a semiotic interpretation/translation process by a semiotic agent into {symbol set₂}.
  • The word "translation" in English and other languages comes from the Latin word translatio, which, in its basic sense, means "transfer," "bring across," hence "interpret" as "transferring" the meaning of one set of expressions into another. Language-to-language translation is thus an obvious form of interpretation. (In English and other languages, a “translator” is also called an “interpreter.”)
• The symbolic transformation that we do in language translations is possible by, first, correlating one set of sign tokens to their types (the lexical forms in a language) with their grammatical patterns, and then, second, interpreting ("processing") the symbolic forms with interpretants (correspondence codes), which, third, generate a second set of sign tokens as output. The "output" tokens represent the interpretation in additional sign tokens (which, of course, can be further reinterpreted in other signs in an ongoing process).
• Translation is one of the most computationally difficult processes to automate. Merging semiotics and linguistics, we say that word and sentence meanings are understood with "semantic maps" and the possible "semantic fields" for word-meanings shared by speakers in a language community. As we know, there is never a direct mapping from one language to another, but we have ways for managing differences and ambiguities. (We do this "disambiguating," as it's termed, by understanding contexts outside single sentences, by sharing background knowledge assumed by speakers/writers and receivers/interpreters of sentences, and by understanding kinds of meanings that belong to specific situations and social-cultural uses.) But computational processes require strict "specification" (well, as strict as we can get) in algorithms and sample data sets. The terms and concepts developed in semiotics allow us to describe and expose the required steps for translation as a process, and further expose the challenges for designing a computational system that seeks to "simulate" human semiotic actions.
• Assignment: First, go to the Google Translate page. The screen interface presents text box windows for the “source” language text and the “target” language text. Choose the source and target languages from the menu. Note that by doing this you have signaled the Google server to provide (in an interactive "real time" "Web service" layer) the corresponding code layers for representing the written language tokens in each window. The interface calls on a human agent to insert character and word tokens into the “source” text box. Type in or copy and paste at least three sentences in the “source” (text box) window. The translation will appear in the displayed tokens in the “target” language text window.
  • Note: Google's "translation service," a black box with many layers of Cloud-server-side processes, represents one application of assigning or delegating a very complex semiotic process -- translation -- to computational processes. Everything "computational" involves physical token representations (as data) and complex software interpretations (processes) that output further tokens. But we can't automate the language-to-language mappings that we "human computers" do, so we rely on a complex system design that can produce approximations of the human process. How? This approximation is computationally possible by using pattern recognition algorithms and fast statistical analysis over huge data set samples of language "tokens" and "strings" (chunks of text tokens). (We will study this topic further in the weeks on information and data.)
• What are we doing, what is happening, in Google's two text windows? We will let the Google Translate service remain a black box of computational functions for now, and focus on the observable inputs and outputs. “Machine translation” (an unfortunate term of the trade) has many layers of processes and code correlations that perform Interpretant functions, “that by means of which an interpretation is made,” which are projected into symbol-token outputs. Without knowing what is happening in the black box of Google’s Translation Cloud of data and machine-learning software, what is happening semiotically that we can observe -- even though the semiotic process can only be done as approximations? Think through what needs to happen (without knowing anything about what's inside the black box) for (1) taking in your "input" tokens (registered in your computer's memory and displayed in the tokens in your screen window), and (2) displaying the tokens produced server-side and sent to the “target” language window.
  • Hints about the process: Input tokens as data --> passed on via an Internet data connection to a black box of Interpretant processes and code correlators into output tokens via an Internet data connection --> receive output tokens as data interpreted through the software and hardware of our systems. (Each step involves a physical process of tokenization, i.e., creating token instances.)
  • Google has also designed the "target" window with layers of interactive interpretive features that again call on a human semiotic agent. Mouse over sections of text. (Sometimes the text generated comes with embedded alternative translations.) Can they be "better" translated as you understand the language codes from source to target? What was missed as you understand the languages?
• Next, copy the text in both source and target windows, and “paste” the text tokens into your discussion post, pasting 3 times for each set.
  • Note: when we use a software routine to "copy" anything, it stores another token instance of what we "copy" as byte-tokens in a temporary memory called a "buffer"; when we "paste" or "insert" the data, the byte-tokens are re-"copied" -- tokenized -- in different memory locations for the file being "edited," then tokenized again through the software and graphics processor to the physical pixel-mapped locations in our screens (our necessary perceptible token instances).
• Next, use the style features in the Canvas edit window, and change the font style and/or color or size of the text characters in 2 of the sets of your text tokens. What have you just done? What is happening when we “retokenize” tokens from one digital instance to another? How do we recognize the characters and words no matter how many times we do this? Haven't you just proved the type/token principle?
• Harder question to think through: how do we "know" what the text tokens "mean," no matter how they are morphed and retokenized, and can we design software to "know" what we know?

Readings:

• Steven Pinker, "Language and the Human Mind" [Video: 50 mins.][start here]
  • A well-produced video introduction to the current state of knowledge on language and cognitive science from a leading scientist in the field.
• Martin Irvine, "Introduction to Key Concepts in Linguistics." (Intro essay; read first).
• Steven Pinker, Words and Rules: The Ingredients of Language. New York, Basic Books, 1999. Excerpt, Chapter 1.
• Andrew Radford, et al. Linguistics: An Introduction. 2nd ed. Cambridge, UK: Cambridge University Press, 2009. Excerpts. Use for a reference to the major topics of linguistics..
  • Review the Table of Contents so that you can see the topics of a standard course Introduction to Linguistics. You don't have to read the whole selection of excerpts. Focus on the Introduction to Linguistics as a field, and the sections on Words (lexicon) and Sentences (grammatical functions and syntax).

Video Lessons: Crash Course: Linguistics

• Good basic short lessons. For this week, view Lessons 1-4 ("What is Linguistics" to "Syntax Trees") and Lesson 16 (Writing Systems).

Background for this Week's Assignment: Visualizing Syntax Structures

• In the readings and video lessons above, you were introduced to the way that we use mathematical models (tree graphs) for mapping the syntactic structure of a sentence. Understanding syntactic patterns is also important for understanding how programming languages must be designed, and how we can encode digital data. For this assignment, you will use software developed for computational linguistics and Natural Language Processing (NLP) for visualizing the syntax structures of sample sentences in a "parse tree."
  • The term "parse" comes from traditional grammar, which means decomposing sentences into their word classes or "parts of speech," like noun, verb, preposition (from Latin, pars = "part"; as in classical Latin grammar, partes orationis, "parts of a sentence, parts of speech"). See Wikipedia: Parsing.
  • Note: Most NLP begins with sorting words tokens and mapping them into a parse tree or parsed with metadata labels for each word..
• Experiment with the XLE-Web: This site, provided by a linguistics research group, aggregates useful computational analysis tools for studying syntax.
  • In the "Grammar" pull-down menu, you will see the languages that can be "parsed" (syntax-mapped) in the the online version of the software and database. For trying it out, choose any language you know. You type in or paste sentences in the text box.
  • Note that many languages have been analyzed by this research group, and are listed on the "Treebanks" page (though not available yet for the Web auto parser interface). You will find examples in Chinese and many other languages. (The "Tree Banks" are data sets of example sentences already parsed and mapped. You may have to click on "accept terms of use" for this section of the database. We will explore more in class).

In-Class Exercises: Experimenting further with NLP "Sentence Parsers"

• The INESS Treebank (Model Parsed Sentences) and XLE-Web (syntax tree tool for input sentences)
  • Selection of Chinese sentences parsed for dependency structure (select the last sample set in the list)
• The Berkeley Neural Parser (constituency parsing in nested levels)

Writing assignment (Canvas Discussion module)

• From the XLE-Web grammar menu, choose "English," and insert a sentence in the text box. Use a short sentence, but one that has a relative clause (a "that," "who," or "which" clause). Then click on "Parse sentence." (You can also chose a second language that you know also for visualizing syntax in the tree graph, but we will use English as a common reference.)
  • The software will give you a very complex graph for the sentence (including options for which syntax "path" seems most likely), using two forms of formal linguistic notation: a constituent (c-) tree structure and functional (f-) bracketed notation structure.
  • We will focus on the "c-" (constituent) structure, so click off the "f-" structure and "discriminants" boxes after viewing the notation. You can also get a "map" of the word tokens in your sample sentence (click on "Tokens"). Take notes on what you discover in the syntax tree and token list. Next, uncheck all the options except "c- structure." This will generate a compact tree without all the syntax details. Use this compact tree for discussion.
• This will be new for you, so don't worry about all the complexities and unfamiliar notation. Do your best to follow what is being presented in the visualization for the "c-" structure. You can experiment with the settings, and also mouse over and experiment with choosing different ways of mapping the tree.
  • Note: The software working in the background on this site is designed to generate thorough abstract maps of sentence structure from your input tokens, including "placeholder" elements that belong with the full syntactic structure but may not appear in your example sentence.
• In your post, describe your experience using the syntax tools, what you learned about syntax and mapping word tokens with all the information in the detailed parse tree, and whatever was unclear about what the syntax visualization means. Insert your sample sentence, and, if possible, an image from a screen shot of the compact syntax tree (with only the "c-structure" checked). I'm sure you will have many questions, so include questions that we can discuss in class.

Readings

• Introductory videos:
  • Code.org, How Computers Work series (short videos): watch Lesson 3: Binary and Data, and Lesson 4:Circuits and Logic (whole series list)
  • Crash Course Computer Science: Electronic Computing (background on the electronics for digital information)
  • Note: these are good quick intros, but they have to skim over some important facts about digital system design. There are no "1s" and "0s" in the physical components of digital information and computing systems or in binary code at the electronic level. "1" and "0" have meanings in human symbol systems, and, by using semiotic design principles, we map (correlate) human meanings and values represented in symbols into a system of on-or-off electronic states. These on/off states are meaningless until assigned a symbolic value from "outside" the physical system.
• Martin Irvine, "Introduction to the Technical Theory of 'Information' (Information Theory + Semiotics)" [a framework to think with].
• Daniel Hillis, The Pattern on the Stone: The Simple Ideas That Make Computers Work (New York, Basic Books: 1998; rev. 2015) (excerpts).
  • For this week, read only the Preface and Chaps. 1-2 (to p.37). Hillis provides good explanations for how we use binary representation and binary logic to impose patterns on states of electricity (which can only be on/off). The key is understanding how we can use one set of representations in binary encoding (on/off, yes/no states) for representing other patterns (all our symbolic systems). Binary encoded "information" (in the digital engineering sense) can be assigned to "mean" something else when interpreted as corresponding to elements of our symbolic systems (e.g., logical values, numerals, written characters, arrays of color values for an image). Obviously, bits registered in electronic states can't "mean" anything as physical states themselves. How do we get them to "mean"?

Optional and for Your Own Study:

• Denning and Martell. Great Principles of Computing. Chap. 3, "Information," 35-57.
  • Read this background as soon as you can for background on the technical details.
• James Gleick, The Information: A History, a Theory, a Flood. (New York, NY: Pantheon, 2011). Excerpts from Introduction and Chapters 6 and 7.
  • Readable background on the history of information theory. I recommend buying this book and reading it throughout the semester, together with Denning and Martell.

In-Class: Demonstration of Telegraph Signals and Code in a working telegraph system!

• Experiment with Morse code in an actual telegraph circuit with vintage equipment.
  • Introduction to Morse and Code (background and dossier of sources) (Irvine)
• Irvine, Information and Digital Encoding: Designing Semiotic Systems: Key Concepts 
  (in-class presentation and discussion)

Writing assignment (Canvas Discussion module)

• First, describe what you learned so far about the technical meaning of information in the context of binary electronics and computing systems. Why and how is "digital information" a logical-symbolic structure that we impose -- by design -- on structures of electrical energy that "know" nothing about human symbol systems? Next, can you discuss, in your own beginning steps, how this information design provides the techniques for creating the essential subsystem or substrate layer for using binary electronics as a physical medium for representing token instances of human symbol systems?
• Thinking further (if you can stretch, to be followed up in the next two weeks): When we combine the models for information structures (from Shannon's electrical engineering designs) and the models for symbolic structures (from Peirce's semiotics), can you see how the “designer electronics” of digital information theory is an elegant engineering solution to a core semiotic problem (representing token structures in binary electronics)? Can you begin to see how "digital information design" is key component in the design of computer systems as "symbol processors"?

Readings and Video Lessons:

• Martin Irvine, "Introduction to Data Concepts and Data Types." [Read first.]

Text and Numerals as a Data Type: Character Encoding

Video Lessons:

• Representing Numbers and Letters as Binary Data (Crash Course: Computer Science)
• Why Do Computers Use 1s and 0s: Binary Transistors Explained (Basics Explained)
• Digital Character Sets: ASCII to Unicode (Computer Science)

Background for Unicode Case Study:

• Wikipedia overview of Unicode and character encoding is useful.
• For reference: The Unicode Consortium official site
  See: Unicode Glossary of Terms | Unicode Technical Site | Unicode History
• For Reference: The Current Unicode Standard, 15.0 (Sept. 2022)
  • See the Code Charts (Tables) for All Languages (Unicode 15.0) (experiment with viewing the code chart for different languages). You find the Unicode "code point" for each character by reading across the row and then down the column.
  • DIY example: This HTML Web "page" (our course syllabus) is encoded as UTF-8 (Unicode Transformation Format, 8 Byte Units), the most commonly used Unicode standard in almost all US and European text encoding software. If you are using the Chrome browser for this course page, do "Cntrl U" (PC) or "Command U" (Mac) and you will see this line of code in the "<head>" element a few lines down:
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">.
  • This line of HTML "meta" code "tells" all Web software (including mobile apps) what version of Unicode text is encoded in this file, so that the decoding module in the program uses the correct "context of interpretation" for the Unicode representations. We never see the "raw" Unicode bytecode strings: all our software is designed to use the standard bytecode (including numbers), but the text data is software-interpreted, and handed off to a graphics processor, to "render" the screen character representations in a "font style" that we interpret as symbol units.
• Unicode Emoji (main page) | Full Emoji List (15.0)
  • Yes! All emoji "characters" are encoded as Unicode bytecode numbers, or they wouldn't work consistently for all devices, software, and graphics renderings. Emoji are not sent and received as images but as bytecode definitions to be interpreted in a software context. Again, code data and device-software contexts and rendering methods are separate levels is the system design.
  • Current Unicode Emoji Chart representing people (with current skin tone options)
  • Unicode "test file" of all currently defined "emojis" [15.0]
    • This is a text file with Emoji symbols encoded to test how they are interpreted and displayed with the software and graphics rendering of various systems. You may find some don't display in your Web browser. The Emojis often look different from device to device. Why?
• Optional: For your reference and further research
  • David C. Zentgraf, “What Every Programmer Absolutely, Positively Needs to Know About Encodings and Character Sets to Work With Text.” Kunststube, April 27, 2015.
    [This is a useful explanation from a programmer's perspective; read through the section on UTF-8 and ASCII.]
  • "Han Ideographs in the Unicode Standard," Yajing Hu (CCT student, final project essay) [
    This is a good essay that looks at the background of Unicode standards for Han characters, and other Asian language families. The Unicode consortium had to consider the same issues for encoding for Arabic and other languages with "non-Roman" character sets and marks.]

Digital Images as Data: On Digitizing Light, Pixels, Image Formats, and Software

• Video Lessons:
  • Images, Pixels and RGB (Code.org, by co-founder of Instagram)
  • How do Smart Phone Cameras Work? (video lesson, Branch Education)
    • Includes excellent background on light and human vision [ignore branding information]
• Backgound on Digital Photography:
  Ron White and Timothy Downs, How Digital Photography Works. 2nd ed. Indianapolis, IN: Que Publishing, 2007. Excerpt.
  • Well-illustrated presentation of the basics of the digital camera and the digital image: study pages on "how light becomes data," and "how images become data."
  • The digital image principles are the same for miniature cameras in smart phones.
• Slightly More Advanced Video Lessons (from Computerphile, if you want to go further)
  • How are Digital Images Represented as Computer Data?
  • How are Digital Images Captured in Digital Cameras?

Writing assignment (Canvas Discussion module)

• Create an example (a token instance) of a digital "data type" that we are studying: either a text string (two sentences) in any language (assuming Unicode is behind what we see), or a digital photo image in a standard format. You will copy it into your post (using an edit feature in the Canvas input window), but first describe a "biography" of your "instance token" from the moment of "creating" it, through all of its encodings in different memory components and inputs/outputs in the devices that you use, and on through the re-tokenization in the Canvas platform.
• For text strings, describe what is happening in your first input "encoding" with the Unicode language bytecode used by your software (like Word or Google Docs). Describe how Unicode "bytecode" for your token instances are held physically in memory in your PC, and are interpreted by software for physical representation in your output display.
  • As you learned this week, the software that we use -- for text characters or images/graphics -- is designed to maintain and transform tokens of specific data type instances by having access to our system's active memory and processing units.
  • Unicode bytecode definitions function as types (in the semiotic sense); that is, the abstract patterns of shapes represented as mathematical definitions in the whole context of Unicode's system of "codepoints." Our software generates individual computer-memory assignable bytes from the abstract pattern; that is, tokens from types. (There are many levels of semiotic type-token relations going on in the background.)
• For a digital photo image, you can create a data token instance with your mobile phone's camera; the information defining the photo will be "written" (stored) in memory as a file. You can view the photo as a tokenization on your screen (interpreted through software), but then "send" it to yourself (email, or Cloud storage that you can access from a computer) so that you can use PC/Mac software to "view" it. If you have a digital camera, you can also think through the steps from "writing" the photo image data on a memory chip, and through the stages of "copying" to your PC (directly or via the Internet). Think through the transitions in tokenization, re-tokenization, and software interpretation. In semiotic terms, the sum total of mathematical formulas for the arrays of pixels that define each digital image file is the abstract type of the image as a symbolic form, and when we view it on screens, we are viewing one physical-perceptible token instance, a tokenization produced by a software interpretation projected through the graphics components of our PCs and devices.
• For either data type example, think through these steps for your data instance's physical "biography" for your discussion post. Hint: when we "copy" or "move" data items we are communicating intentions, through software routines (the subprocesses in any program) for ongoing retokenizing of the underlying physical bit/byte-level "information" as other physical instances in other digital memory locations. (Indexing and interpreting systems in our devices keep track of the data types and whole files stored in memory locations.)
  • (1) Describe (and ask questions) about the encoding/decoding processes of the data type instance as data. What is the relationship between software specifically designed for creating (inputing) and displaying (outputting) a data type for how the instances are rendered in representations on our pixel-based displays? Our "local" PC (or Web-enabled app on a mobile device) and the "remote" Canvas server are designed to facilitate "copies" of your data instances (re-tokenizations), and return "copies" (token instances) to be output through the memory, software, and screens on our devices.
  • (2) Describe (as you understand so far) the E-information and Data levels at work in your data instance in the digital design of computers. "E-information" explains how the systems (our devices, the Internet, Web servers) are designed to manage copying/replicating tokens of bits/bytes reliably in the background (regardless of the data type). But we deal with bytes at other levels in the system design as data types and as file types interpreted in software. We perceive and work with token instances of software-interpretable data, not the individual bits in memory locations reliably transferred and stored there as designed in the information engineering requirements.

Readings and Video Lessons:

• Prof. Irvine, Computer System Design Principles (What is a Computer? What is Computation?). Video. 20 mins. You can also view this video directly in your browser (not from YouTube) (link) [switch to 1080p HD quality].
  • I made this video for CCT 505, but with a view that applies to other courses.
    Note: I don't use much of the semiotic terminology that you're learning in this course (introducing that would have taken a longer presentation), but you will see how the concepts in this course are assumed in the descriptions of the system designs.
  • Here are the slides (as Google Slides), so that you can also study the presentation more slowly on your own, if you'd like to.
• Crash Course Computer Science: Video Lessons
  • For this week, complete Lessons 3-8. [View the lessons that you haven't done yet, or view the whole sequence.]
• Martin Irvine, "Semiotic Foundations of Computing and Information Systems." Chapter in Bloomsbury Semiotics, 3 vols., ed. Jamin Pelkey (London: Bloomsbury, 2022); vol. 2, 203-237.
  • Download this file for easier reading, and print it out if you can. Read pp. 203-237, 217-224 (you can skip over the background histories).
  • I wrote this book chapter with students in mind. Please ask questions. The 3-vol. book is intended to be "encyclopedic," so I had to cover a lot, but there is much that needs explaining.
• Continue reading: Denning and Martell, Great Principles of Computing (selections). [Here is the whole e-Book in the shared folder.] Read as far as you can in these sections for technical introductions to key concepts:
  • From Chap. 4 (read 59-70, top paragraph); from Chap. 5 (read 83-88); from Chap. 6 (read 99-105 top). (We will return to the full chapters later).

Optional and for Reference: Background on the Technical Design of Computers

• These texts are not for reading straight through, but are good reference sources for understanding computer system design and physical components. How Computers Work is just that: there is no why or explanation of design concepts, but it's a good, well-illustrated "inside the blackbox" view of standard hardware (which also applies to smartphones and mobile devices).
• David A. Patterson, and John L. Hennessy. Computer Organization and Design: The Hardware/Software Interface. 5th ed. Oxford, UK; Waltham, MA: Morgan Kaufmann, 2013. Excerpts from Chapter 1.
  • Excellent overview of important concepts for system architecture from PCs to tablets. For beginning computer engineering students, but accessible.
• Ron White, How Computers Work. 9th ed. Indianapolis, IN: Que Publishing, 2007. Excerpts.
  • Part One: Boot Up Process (Basic History and Design Architectures)
  • Software Applications

Writing assignment (Canvas Discussion module)

• Discuss one or two main discoveries that you learned about computer system design from our perspective of symbolic systems. Think through the following system outline, and ask questions about what you don’t understand yet:
• Was it clear how digital computer system design is based on a model for implementing symbolic processes physically in two main connected subsystems -- a subsystem for (1) “symbols that mean” (physical representations for “data” as encoded from our symbol systems as tokens in binary bytes) and (2) “symbols that do” (physical representations at the level of binary tokens in programming code for performing actions on representations in subsystem (1))? Was it clear how the system design interprets and combines the two subsystems for performing what we call “computations”? Describe as much of the details that you understand.
  • Note: Although computer system processes are unobservable as encoded binary electronic structures, can you see how computers (large or small) are not really "black boxes" (in the sense of being beyond human understanding -- because we designed them with and for our symbolic capabilities)?
  • Looking ahead to the next two weeks: Having a basic understanding of the concepts behind computer system design will really help you understand why a programming language’s “code” is designed the way it is, and what we are doing when writing programs and running software.

Introductions and Video Lessons:

• Video Lesson: Prof. Irvine, Introduction to Computational Thinking and Software Concepts (From "Key Concepts in Technology" course)
• Video Lesson: Computational Thinking: What Is It? How Is It Used? (Computer Science Intro)
• Main "Computational Thinking" methods:
  Decomposition: Breaking down a complex problem into manageable units that go together; a development of "systems thinking" = managing a complex system through subsystems that provide specific functions that can be combined in an overall system design.
  Pattern Recognition: Discovering patterns in examples of similar tasks or problems so that we can make generalizations that hold over any new example or instance.
  Abstraction: Focusing on one level of a problem at at time, and bracketing off the complexity of dealing with the design requirements of other levels.
  Algorithm Design: Designing the logical steps for a general procedure that can be coded in a specific programming language as part of a whole program (= "runnable software").

Video Lessons: Crash Course Computer Science

• Continue with these Crash Course Computer Science Lessons for backgrounds on programming:
  9 (Instructions and Programs); 11 (Early Programming); 12 (The First Programming Languages); 13 (Programming Basics: Statements and Functions).
• In the in-Learning Lesson below, Python is used as a teaching language for introducing programming fundamentals. With the background so far, you should also be able to understand the more universal programming principles that every programming language must include.

Main Reading for Introduction to Coding Tutorial:

• David Evans, Introduction to Computing: Explorations in Language, Logic, and Machines. 2011 edition. (The Professor's Open Access site for updates: https://computingbook.org.)
  • As background for this week of the online video tutorial lessons, read chapters 1-2 (Computing, Language). Download the book: you can always return to other chapters for reference and self-study.

Main Assignment: Video Lessons for Hands-On Learning

• in-Learning: Programming Foundations: Fundamentals
  • Sign in to this online course with your GU email ID.
  • Short video lessons that introduce programming concepts with Python as the learning language. The teacher uses code editing programs and interfaces for the Mac platform, but you can do the same with software tools for Windows PCs.
  • Study as far as you can units Introduction, 1 and 2 for this week. You can follow the basic concepts in units 1-2 without installing your own IDE program ("Integrated Developer Environment," a program to write programs) and the Python Interpreter for your platform (OS).
  • To go further in trying out your own code for next week, install the Python Interpreter on your own PC (instructions for Mac and Windows platforms in video), and an IDE for writing code and then "running" it on your PC. The video will explain how Python uses an "interpreter" program to send "runnable" (executable) binary code to your system. (The course teacher uses the "Visual Studio" program -- a widely used IDE -- for writing and demonstrating the Python "Source Code".)
  • Take notes on what you learned and questions you have about programming concepts and how our "code" gets communicated and interpreted in a computer system.

Writing assignment (Canvas Discussion module)

• Describe what you learned about programming and code from the background video lessons and from working through the in-Learning video lessons for this week. Were you able to make connections to the computing principles and concepts for "code" that we've studied? Were any key concepts clearer? What questions would you like explained further in class?

Readings for Programming Fundamentals:

• David Evans, Introduction to Computing: Explorations in Language, Logic, and Machines.
  • For this week, read chapters 3-6 (Programming; Problems and Procedures; Data; Machines). [Download the book: you can always return to other chapters for reference and self-study.]
  • These chapters introduce the more technical and logical-mathematical aspects of the "how" and "why" in programming language design. In our context, the point is learning about the reasons for the design of a special code language (C, Python, Java, etc.), a symbolic code that allows us to communicate with the structures of digital computer systems.
  • A programming language must be designed to implement step-by-step procedures that can be represented formally in special symbols (the "code" vocabulary) that allow us to (1) assign human logical actions to perform computations (in the processors) on (2) physical representations of symbol tokens for data (in "memory" components). These two dimensions of programming are based on the principle of "one-to-one correspondence" mappings to (3) the combined binary architecture of digital computer systems.
• Denning and Martell, Great Principles of Computing. Chapters 5, 6, 10 (Programming; Computation; Design). [These chapters will fill in your background for how programming and code are implemented in computer systems.]

Crash Course Computer Science Lessons

• Continue with the Crash Course Computer Science Lessons: 14 (Introduction to Algorithms) and 15 (Introduction to Data Structures (Programming Basics: Statements and Functions).

Main Assignment: Continuing Lessons for Hands-On Learning

• in-Learning: Programming Foundations: Fundamentals
  • Study Units 3-5 and the Conclusion for this week. Again, you can follow the basic concepts and procedures presented in the video lessons without installing the Python Interpreter and your own IDE program, but you will get more into "hands on" coding if you have the software tools on your own system.
  • Continue to take notes about what you are doing and learning, as well as questions about the programming principles.

Writing assignment (Canvas Discussion module)

• In your discussion post, capture your main learning steps and questions from the readings, video lessons, and in-Learning lessons for this week. Think through what you've studied in Weeks 8-9 and this week: have you made further "aha!" connections, and have new questions emerged at this point in the course?
• As you think over your learning, refer also to the learning goals for this week in the first paragraph of the "Learning Objectives and Topics" above. Are these foundational principles of programming, software, and computer systems more understandable? What questions or topics would you like to go over more in class?

Readings and Video Lessons:

• Prof. Irvine, "Introduction to the Internet and Web as Semiotic Systems"
• Video Lessons: Background on the Internet and Web Technologies:
  • Crash Course, Computer Science Lessons:
    • Computer Networks: Introduction
    • The Internet
    • The World Wide Web
  • Code.org Video Lessons: "How the Internet Works": Watch lessons 1-5.
• Denning and Martell, Great Principles of Computing, Chap. 11, "Networking."

Video Lessons for Introductions to HTML and Web Coding

• in-Learning has a large set of Video Courses on Web Development (if you'd like to see what they offer and what you could study on your own later.)
• For this week, study these introductory lessons, as far as you can:
• in-Learning: HTML Essentials:
  Study the basics of "What is HTML?", Formatting Text, Links, and Images.
• Optional: The next steps in a bit more advanced lessons (if you have time and can follow):
• in-Learning CSS Essential Training
• In-Learning JavaScript Essential Training
• After the background in basic coding for HTML documents, try out the code with the Tutorials at W3Schools.com:
  • Learn and Try Out HMTL Code
  • Learn and Try Out CSS Basics
  • Learn and Try Out JavaScript Basics
• Note: you can always return to these lessons after this week to follow up and learn more.

Shared Doc for Inserting Your HTML Test Code for this Week's Assignment

• Link to Google doc (for inserting your own code).

In Class: Follow the Code

• JavaScript discovery html file.
• Examining the "code source" of Web pages. With the Chrome browser, type "ctrl-u" for any displaying page, and you will see the "source file" as it comes to your browser. (Other browsers will have a feature for "revealing" the source file as "raw text".)
• Experimenting and practice with HTML basic code. Group project on HTML file.

Writing assignment (Canvas Discussion module)

• This week's assignment has two parts:
  (1) With the background on the design of the Internet and Web, and from your learning about the HTML code suite in the lessons, discuss some main points that you learned about the Internet/Web and coding for the Web. Can you describe some features of the HTML code suite and Web "metamedia" interfaces that subsume and combine many of the principles that we have studied for semiotic systems and subsystems, data types, and digital media? What are the main design ideas behind "hyperlinking" and multimedia display interfaces?
  (2) From what you learned in the HTML Web coding lessons, write some HTML markup and code for data that you would like to try out and see "run" from a web server. Try out some basic code for formating, font definitions, and image inclusion. Copy and paste your test code and content into the shared Google doc. I will then copy your coded text into an .html file, upload to my web server, and you will see how it works (and if you need to correct syntax or code terms in the markup).

Readings & Video Introductions:
Interactive Design Principles and Metamedia for Semiotic Processes

• Martin Irvine, The Semiotic Design Principles of Interfaces (read first)
  • I've synthesized a lot of background history from many sources for opening up the design concepts that enabled our kinds of computers today. Includes a research bibliography if you want to follow up on any of these topics.
• Martin Irvine, From Cognitive Interfaces to Interaction Designs with Touch Screens
  • Follow the methods for designing for symbolic actions in Interactive System Design.
• Video Lessons: Crash Course Computer Science
  • Screens and 2D Graphics [the technical steps behind today's screens]
  • 3D Graphics [the design concepts behind simulating 3D on 2D screens]
  • The Development of the "Personal Computer"
  • The Development of Graphical User Interfaces
  • These lessons will provide good technical background, but we need our methods to answer the "why" questions: "why are interactive systems designed this way?", and "what are we actually doing in interactive computing?" (Hint: it follows from symbol processing by cognitive-semiotic agents; us!)

History and Theory Background:

• Alan Kay, "Programming Your Own Computer," World Book Encyclopedia, 1979.
  Think about what PCs would be like if Kay's design concepts (and semiotic assumptions) had been adopted in the consumer PC industry!

Semiotic Foundations of Interaction Design Principles

• Janet Murray, Inventing the Medium: Principles of Interaction Design as a Cultural Practice. Cambridge, MA: MIT Press, 2012. Excerpts from Introduction and Chapter 2.
  • Read the introduction for this week. This book is an excellent recent statement of the contemporary design principles developed in the cognitive design tradition, which assumes that computer interfaces are designs for semiotic systems.

Optional: Background in the Technical History of Interaction Design

Brad A. Myers, “A Brief History of Human-Computer Interaction Technology,” Interactions 5, no. 2 (March 1998): 44-54.

• This excellent synthesis of the history was written ten years ago, and we continue to use the interface design principles summed up here. If you have time this week, think about how the different "conceptual leaps" in design (with supporting technologies as they became available) were motivated by semiotic-cognitive uses and finding ways to bring more cognitive agency to people who use computer systems and digitized symbolic media types.

Supplementary Sources for Further Research: Historical Background

• Collection of Original Primary Source Documents on Interface Design (in pdf).
  • I provide this selection of texts because graduate students should have access to the primary sources of their fields of study. Do not read these texts fully for this week, but review them for their historical significance, and as the sources for references in the readings and video lessons.
  • Possible Final Project topic: If you are interested in the history of concepts behind our interfaces and interactive computing -- including the possibilities that haven't yet been realized in today's products -- this collection of sources would provide rich material for a final project! You can uncover for yourself the often implicit semiotic design principles for interfaces and interactions, and how this history is part of our story of computers as symbol processors and "metamedia" systems. You could make your own connecting links through the concepts in the course, and explain how the key concepts about Code and semiotic systems make our interfaces, digital media types, and interactive systems possible today. We can discuss the readings and documentary videos further next week.
• Contents of the Collection of Documents (descriptions are in the pdf file):
  • Vannevar Bush, "As We May Think," Atlantic, July, 1945.
  • Ivan Sutherland, "Sketchpad: A Man-Machine Graphical Communication System" (1963).
  • Douglas Engelbart, "Augmenting Human Intellect" (project from 1960s-1970s).
  • Alan Kay, Xerox PARC, and the Dynabook/ Metamedium Concept for a "Personal Computer" (1970s-80s)
• Documentary videos on the history of interface and interaction designs:
  • Alan Kay on the history of graphical interfaces: Youtube | Internet Archive
  • Demo of Ivan Sutherland's Sketchpad, Lincoln Labs, MIT (c.1963).
    See first: the short video of Alan Kay's commentary on Sutherland's Sketchpad graphical system.

Writing assignment (Canvas Discussion module)
Reflecting on your learning over the past few weeks and this week, develop your own description of an interactive feature (not a mobile app):

• From your study of the concepts and technical design steps in the readings and video lessons, describe some of the key developments that enabled computing systems to be designed as general symbol processors (not just calculating machines) with "interfaces" that non-specialists could use. What were the major "conceptual leaps" that enabled a new "paradigm" (model, design standard) for what a computer system could be? How was this new paradigm made "operational" by new designs for interfaces, software, and digital data types -- all being motivated by enabling people (now understood as co-agents with a computer system) to communicate with computer systems and direct the input and processing of symbolic representations, actions, and intentions?
• In your discussion of some of the key concepts, use examples of software and interface features now "built in" to our current interface designs and ways of directing and interacting with digital data and media. Do you see any ideas and technical possibilities for interactive multimedia systems that they early thinkers and designers hoped for, but that have not yet been realized in the current products of the computer industry?

In class:

• Further Discussion of the semiotic foundations of interactive computing systems and graphical "Two-Way" interfaces in pixel-based screens.
• Discussion of your main learning discoveries and "take-aways" from the course

Readings for Synthesizing Thoughts and Learning for Your Post and Class Discussion

• Michael S. Mahoney, "The Histories of Computing(s)." Interdisciplinary Science Reviews 30, no. 2 (June 2005): 119–35.
  • This is a richly detailed and well-informed essay by a major historian of computing that synthesizes technical and humanities perspectives. Focus on a close reading beginning at the bottom of p.128 to the end (p.134). Mahoney's main points about (1) there can be no one (or any) linear history of computing, (2) the fact of multiple "communities of practice" that shaped kinds of computing and applications, and (3) the importance of design and design concepts are now well-accepted. Though the examples are from stages of computing up to 2005, his main points and concluding focus on designs for symbolic processing will always be true.
• Re-read: Irvine, "Semiotic Foundations of Computing and Information Systems." Chapter in Bloomsbury Semiotics (London: Bloomsbury, 2022), pp. 203-212, 217-225.
  • Are the main concepts and technical descriptions more understandable for you now? What topics or questions would you like to discuss or research further? (Download this file for easier reading.)
• Denning and Martell, Great Principles of Computing. Read Chap. 10 (Design) and Chap. 12 (Afterword). [Download the book for reference.]
  • For your own further reading and research, be sure to consult the notes and bibliography. For Final Projects on any topic covered in this book, you will do well to begin with any references cited.
    

Planning for Writing Your Final Capstone Project

Instructions and How to Prepare for Your Final "Capstone" Project (pdf).
(Save and print out)

• As you plan your research and writing, consult my Writing to be Read (also a pdf version to print out): a guide for the structure and logic of research papers.

Writing assignment (Canvas Discussion module)

• As you reflect over what we've studied and what you have learned, what stands out for you in what you have learned and discovered? Were earlier questions answered? What new questions would you like to follow up?
• Consider, too, how the methods, key concepts, approaches that we have studied will apply to other topics or courses that you want to study in CCT.
• Looking toward your final "capstone" project, was there a topic or approach that you would like to learn more about, and develop further on your own?
  

Resources for your Research (curated books and articles in our Google Drive):

• Start here for background and research sources:
  • All Folders (by Main Topic)
  • Main readings for 711
  • Computing
  • Design and HCI
  • Semiotics, Computation, Digital Media
  • Semiotics (main sources and applications in technology)

A Model for the format of an interdisciplinary research essay:
Study the structure of this published article and use of references

• Jiajie Zhang and Vimla L. Patel. "Distributed Cognition, Representation, and Affordance." Pragmatics & Cognition 14, no. 2 (July 2006): 333-341.
  • Read this short article for the structure and format -- from the Abstract to the Conclusion, and use of references. (This article is a good "synthesis" -- connecting concepts from several fields -- for an interdisciplinary view of major design concepts for interactive computing developed after Engelbart's "paradigm shift".)

In Class: Open Discussion and Presentation of Final Projects

• We will have a roundtable discussion of the current state of your research for your topic, the concepts and methods you are working with, and references for your bibliography. This is a good opportunity to organize your thoughts, and get feedback and suggestions from the class.

Instructions for Completing and Submitting Your Final Project

• Follow the the Instructions for your Final "Capstone" Project (pdf).
• Remember: Use Zotero for organizing and formatting your references. All references in your essay must conform to a professional style for citing and formatting references (choose one in Zotero). Professional practices matter!
• How to link your final project in the Canvas "Final Projects" Discussion topic:
  As explained in "Capstone Project" pdf:
  • Output ("save as") your document (as composed in Word or Google Doc) as a pdf, and create a link to the file in your Canvas "post" for the "Final Projects" Week. Options for your pdf file: (1) upload it to Canvas, and link to it; (2) upload it to a folder in your own Google Drive account (and set the file permissions to "Shareable" with anyone with the link; (3) upload the file to your own website, and copy the full URL for the link in your Canvas post.
  • In your Canvas post, use the title of your project essay for the link, and copy your abstract in the Canvas discussion post under your link. Test the links and proper viewability of your file.
• Due Date: Final projects are due to be posted in the Canvas Discussion space 7 days after the last day of class. Link your pdf document (with title and abstract under the link) in the flan week's Discussion topic, "Final Projects."