Course modules

Module 0001: Introduction to Client/Server Networks
Module 0002: Introduction to Open Source
Module 0003: Basic Linux CLI commands
Module 0004: Starting with Linux
Module 0005: Linux structure
Module 0006: General Debian Linux Installation
Module 0007: Physics for Driving
Module 0008: QEMU Installation
Module 0009: Debian Linux Installation
Module 0010: Linux to go
Module 0011: Host-only Security
Module 0012: Variables, Assignments, Expressions and Sequences
Module 0013: Conditions and Conditional Statement
Module 0014: An Engineering View of Rims and Tires
Module 0015: Pre and Post Conditions
Module 0016: Loops
Module 0017: Introduction to Moodle
Module 0018: Discrete structure? Why the torture?
Module 0019: Integer Representation
Module 0020: Do I need Data Structure?
Module 0021: Deb4Dev Package
Module 0022: C/C++ in Linux (and you call this easy?)
Module 0023: Basic Propositional Logic
Module 0024: Hello, again, C!
Module 0025: Quantifiers in Propositional Logic
Module 0026: Basic data structure mechanisms
Module 0027: C versus C++
Module 0028: Definition hiding
Module 0029: C++ Class Basics
Module 0030: (C++) Object initialization, clean-up and assignment
Module 0031: Algorithms and Developers
Module 0032: Introduction to Proofs
Module 0033: Data Abstraction
Module 0034: Data abstraction in C++
Module 0035: Proof by Induction
Module 0036: Array and records as ADTs
Module 0037: ``This'' is the magic of C++
Module 0038: Operator overloading
Module 0039: Set theory
Module 0040: Nested statements
Module 0041: The make program
Module 0042: Introduction to N-tuples
Module 0043: List ADT
Module 0044: Square grid ``floodfill'' algorithm
Module 0045: Data members and methods
Module 0046: Pre and post conditions
Module 0047: Relations
Module 0048: Pointers and dynamic memory management
Module 0049: Top-down design
Module 0050: Functions
Module 0051: The Stack and Queue ADTs
Module 0052: Stopping memory leak and memory corruption
Module 0053: Symbols for discrete structure
Module 0054: Introduction to arrays
Module 0055: Containers, proxy and iterators
Module 0056: Physics for small robots
Module 0057: Micromouse project management
Module 0058: Counting is not a child's play
Module 0059: Basic Inheritance
Module 0060: Searching in a sorted array
Module 0061: Micromouse map representation
Module 0062: Discrete probability distribution
Module 0063: Someprofs secure connection
Module 0064: File operations in C
Module 0065: Subroutines: control flow
Module 0066: Up, down, static and dynamic casting
Module 0067: Accessibility and Assistive Technologies
Module 0068: Recursive deﬁnitions and algorithms
Module 0069: Composition vs. Inheritance
Module 0070: Slice, overload, override and hide
Module 0071: Copy constructor
Module 0072: Recursive list processing
Module 0073: Local variables and parameters
Module 0074: Methods under the hood (meth in the hood)
Module 0075: An overview of the legal requirements of web accessibility
Module 0076: Returning values
Module 0077: Recursive merge sort
Module 0078: Local var., by value, or by reference?
Module 0079: Non-recursive merge sort
Module 0080: Polymorphisam, constructors and destructors
Module 0081: Types and Records
Module 0082: Big, little, Oh, Omega and Theta
Module 0083: Private and protected inheritance
Module 0084: Abstract class
Module 0085: Search algorithms and their complexities
Module 0086: Multiple inheritance
Module 0087: Quick sort
Module 0088: Accessibility barriers, standards, guidelines and validators
Module 0089: C++ stream input/output
Module 0090: Categories of time complexity
Module 0091: Basic Boolean and logic
Module 0092: Boolean expression minimization
Module 0093: C++ Exceptions
Module 0094: Writing pseudocode subroutines
Module 0095: Half adder and full adder
Module 0096: Introduction to binary trees
Module 0097: Basic HTML coding techniques for accessibility
Module 0098: Tables and CSS
Module 0099: Minterm, maxterm and functional equivalence
Module 0100: Floating point numbers
Module 0101: Introduction to template classes in C++
Module 0102: Good trees, bad trees and ugly trees
Module 0103: Finite state automata
Module 0104: Layout design using CSS
Module 0105: The standard template library (STL)
Module 0106: Headers for accessibility
Module 0107: Binary heap
Module 0109: Basic hash tables
Module 0110: Smart pointers and beyond
Module 0111: Introduction to formal languages
Module 0112: Introduction to graphs
Module 0113: Nondeterministic automata
Module 0114: ADA Plugin and applet requirements
Module 0115: Linux Networking Low Level Details
Module 0116: Intranet vs. Internet: an overview
Module 0117: Basic TCP/IP Conﬁguration
Module 0120: Authentication
Module 0121: Linux email server
Module 0122: Virtual Network Computing
Module 0123: DNS and BIND
Module 0124: An Introduction to Samba
Module 0125: An introduction to SSH
Module 0126: Remote back up using NFS, SMB, SSH and sudo
Module 0127: IPTABLES fundamentals
Module 0128: Squid 4 Cache
Module 0129: DHCP Server and Client
Module 0130: Short Circuited Evaluation
Module 0131: Don’t Recode, Rethink for Accessibility
Module 0132: Using myweb (virtual LAMP server)
Module 0133: Thread Management of a Micromouse
Module 0134: Computer Industries and Occupations
Module 0135: Very basic accessibility HTML
Module 0136: DP, in general
Module 0137: How computers work
Module 0138: Learning Programming using XLogo
Module 0139: Simulating a Visually Impaired Web Browser
Module 0140: IR reﬂectance sensor
Module 0141: What is an operating system?
Module 0142: Computers, jobs and your future
Module 0143: Introduction to Visual Basic for Application
Module 0144: Adding and subtracting numbers, binary style
Module 0145: Processor registers
Module 0146: Introduction to Linux security
Module 0147: Network interfaces, ports, services and daemons
Module 0148: Setting up virtual servers
Module 0149: The organization of VBA in Access
Module 0150: Protocols
Module 0151: VBA variables
Module 0152: Necessary Daemons
Module 0153: Samba
Module 0154: Using OpenVPN with Multiple VMs
Module 0155: The Root account
Module 0156: Dialog box user interface: textboxes
Module 0157: Installing additional packages with a base Debian installation
Module 0158: Groups, users, and permissions
Module 0159: GUI controls and event handlers
Module 0160: File-based encryption using GPG
Module 0161: Using Macros in Access
Module 0162: Conditions and conditional statements in VBA
Module 0163: Using SSH for remote access
Module 0164: Backing up and encrypting lots of files
Module 0165: Using pattern matching in VBA
Module 0166: Malware in Linux
Module 0167: Loops in VBA
Module 0168: Extending a VM disk image
Module 0169: ClamFS: Theory and Application
Module 0170: Writing and using subroutines in VBA
Module 0171: Making VMs talk to each other and the world
Module 0172: Built-in assistance in VBA
Module 0173: Using gschem to design new symbols
Module 0174: Linux, Unix and Windows
Module 0175: Linux Server File Systems (local)
Module 0176: Setting up RAIDs and LVM in a VM Debian Installation
Module 0177: What do you use a Linux server for?
Module 0178: Linux file systems
Module 0179: Linux user access control
Module 0180: PCB design using gEDA gschem and pcb
Module 0181: Partition resizing using GPartEd
Module 0182: Advanced mode bits in Linux
Module 0183: A Linux-based AVR Development Platform
Module 0184: Micromouse Circuit Board Design Checklist
Module 0185: Debugging RTK related issues
Module 0186: adduser, deluser, chown and chmod
Module 0187: Using a Virtual Distributed Ethernet (basics)
Module 0188: Transitioning from a Windows host to a Linux host (QEMU)
Module 0189: Virtual machines, virtual switch and virtual network
Module 0190: How to back up a Moodle server
Module 0191: Printing in Linux
Module 0192: How not to back up files on a server
Module 0193: Using SSH to back up a server
Module 0194: Basic networking in Linux
Module 0195: Setting up a Kerberos Server
Module 0196: A quick introduction to LDAP
Module 0197: X11, VNC and SSH for remote desktop management
Module 0198: Setting up a DHCP server
Module 0199: Logging system messages in Linux
Module 0200: Debugging a server/client configuration
Module 0201: MySQL in Linux
Module 0202: Cron and At for scheduling tasks
Module 0203: OS, App and the web
Module 0204: Enterprise computing
Module 0205: HTTP serving using Apache
Module 0206: Setting up Postfix as an SMTP server
Module 0207: DNS, in general
Module 0208: IPTABLES, the basics
Module 0209: Files in Linux, a user’s perspective
Module 0210: Using a VM to do coding homework in Linux
Module 0211: Why assembly programming?
Module 0212: Memory and I/O access
Module 0213: File types in Linux
Module 0214: Why everything is a file
Module 0215: 386 instruction addressing modes
Module 0216: Interrupts and system calls
Module 0217: Adding in assembly language
Module 0218: Subtracting in assembly language
Module 0219: “Compiling” control structures
Module 0220: Socket programming
Module 0221: Requesting Linux system services in an assembly language program
Module 0222: Using the stack in assembly language programming
Module 0223: Using select
Module 0224: Parameters, local variables and return values
Module 0225: Of Processes and Threads
Module 0226: Structures, arrays and pointers in Assembly Language Programs
Module 0227: Threads
Module 0228: Object Oriented Programming for the Procedural Programmer
Module 0229: PCB Design Basics
Module 0230: Designing an Embedded System Controller
Module 0231: Basic Embedded Controller Circuit
Module 0232: Subroutine tracing
Module 0233: Statistical method to detect cheating
Module 0234: Computer Security: An Overview
Module 0235: Linux
Module 0236: TCP, UDP and ICMP
Module ????:
Module 0238: Tools to harden Linux
Module 0239: VBA user interface object basics
Module 0240: File Protection in Linux
Module 0241: Building your first (useless) Android app
Module 0242: Configurating and Diagnosing General Networking Issues
Module 0243: How to process a big scanned PDF file
Module 0244: Securing MySQL Connections
Module 0245: Heavy versus light pellets
Module 0246: Running a pre-installed Linux system
Module 0247: The argument for oﬀ LMS LaTeXcontent authoring and storage
Module 0248: Amazon Web Service
Module 0249: Tak’s Greetings 2017 Spring
Module 0250: Functional stacks
Module 0251: Personalities and Programming/development
Module 0252: Truth and Logic
Module 0253: Getting started with Android Studio
Module 0254: Structure of a simple Android app
Module 0255: Binary addition and subtraction as boolean operations
Module 0256: What is an App?
Module 0257: Setting a event listener in general
Module 0258: Java classes
Module 0259: The Model-View-Adapter architecture
Module 0260: Signed integer representation
Module 0261: Android Activities
Module 0262: How to copy Android Studio project to another computer
Module 0263: App development concepts and models
Module 0264: Android Fragments
Module 0265: Android App Bar
Module 0266: Apps, processes, threads, activities, services, and etc.
Module 0267: Base-10 Scientiﬁc Notation to Double Precision Floating Number
Module 0268: Accessing sensors from an Android App
Module 0269: Using a list view in Android
Module 0270: Planning a project
Module 0271: Sockets in Android
Module 0272: How to use the camera in Android
Module 0273: Android certiﬁcates, signing and other security concerns
Module 0274: Firebase in Android App
Module 0275: Building from a plain project
Module 0276: Subroutines using the Toy processor
Module 0277: The truth about truth
Module 0278: Taking a class from Tak
Module 0279: Boolean operators
Module 0280: Basic set theory
Module 0281: Physical states, truth, numbers, and computer
Module 0282: Values, numbers and bases
Module 0283: Adding binary numbers
Module 0284: Subtracting binary numbers
Module 0285: Basic quantiﬁers
Module 0286: Common part of Tak’s syllabi
Module 0287: The Big Picture of PHP Scripting
Module 0288: Set theory using quantiﬁers
Module 0289: Functions as sets
Module 0290: Injection, Surjection and Bijection
Module 0291: Signed value representation
Module 0292: Conditional statements in PHP
Module 0293: Aleph null
Module 0294: PHP quoting
Module 0295: Binary number comparison
Module 0296: Floating point number representation
Module 0297: Propositional logic
Module 0298: D-ﬂipﬂop and other basic memory devices
Module 0299: Clocked circuits
Module 0300: General Web Script Logic
Module 0301: General MySQL use in a PHP script
Module 0302: Database entry browsing and selection
Module 0303: “Compiling” control structures for Tak’s Toy Processor
Module 0304: Calling and returning from subroutines
Module 0305: Counting
Module 0306: Returning a scalar value
Module 0307: Parameters and local variables
Module 0308: Discrete probability
Module 0309: Logging in and session maintaining in PHP (server-side)
Module 0310: Graphs
Module 0311: Uploading ﬁles and linking ﬁles to a database table
Module 0312: Relations
Module 0313: Solving focusing markings of a side focusing scope
Module 0314: Understanding Tak’s Toy Processor (TTP)
Module 0315: Predicate calculus via Prolog
Module 0316: Getting started with Google App Engine
Module 0317: Understanding concepts
Module 0318: How Logisim assigments are graded
Module 0319: Introduction to algorithm design and pseudocoding
Module 0320: How do I study TTP?
Module 0321: Understanding MBTI letter percentages
Module 0322: TTPASM postﬁx expressions
Module 0323: Some steps to develop algorithms
Module 0324: Javascript Promises
Module 0325: Interacting with a Google Sheet from a command line interface script
Module 0326: Personality Awareness and Organizational Eﬀectiveness
Module 0327: Getting started with AppInventor
lost module 0328!
Module 0329: Node Express + HTTPS + Apache2
Module 0330: Setting up a Power sandbox for the Master project
Module 0331: Quick start guide to TK4
Module 0332: Basic JCL
lost module 0333!
Module 0334: Debugging NodeJS programs
Module 0335: What is ’await’?
Module 0336: Enabling async Express+node
Module 0337: Using mysql-await to access MariaDB
Module 0338: Authentication
Module 0339: Asynchronous CLI command execution
Module 0340: Express session
Module 0341: Typos, argh!
Module 0342: Using cheerio and regex to change all hrefs to full URLs
0343 Note taking with Joplin
Module 0344: Deep understanding
Syllabus of CISP 310 in Spring 2022
Module 0000: DDDD Title
Module 0347: So you got an app to dev
Module 0348: What I wish I’d known before I started this OER rabbit hole
Module 0349: Concrete green garden
Module 0350: relaTable (Google Sheets to track tables)
Module 0351: Signed vs unsigned integer representation
Module 0352: Binary comparison
Module 0353: Creating content with equations
Module 0354: How to understand
Module 0355: Taking and Maintaining Notes
Module 0356: Using [n]vim for Markdown
Module 0357: Getting Started with GoDot
Module 0358: Event driven coding in GoDot
Module 0359: Values, types and expressions
Module 0360: An UI app to experiment with operators
Module 0361: Assessment considerations
Module 0362: Game Development at ARC
Module 0363: GoDot: Members of a node
Module 0364: An example of how to understand something
Module 0365: How to take, review and use notes
Module 0366: Tak’s STEM classroom instructor workstation set up
Module 0367: Debugging C in Replit
Module 0368: Tracking changes of a circuit
Module 0369: Thoughts on data modeling
Module 0370: Logic
Module 0371: Tracing TTP code execution
Module 0372: Caller-callee agreement
Module 0373: Callee only considerations
Module 0374: Structures and arrays in TTPASM
Module 0375: TTP code execution tracing
Module 0376: C notations to describe what is in a register
Markdown for OER
Module 0378: What is logic?
Module 0379: MBTI and computer science classes
Module 0380: The Genie called GPT
Module 0381: The DDC approach of problem solving
Module 0382: Summation and other “big-operators” defined recursively
Module 0383: TTP
Module 0384: TTP conditional jumps
Module 0385: PCP hammer valve system
Module 0386: Building a deBugger
Module 0387: Steps to implement a program in TTPASM
Module 0388: SyncFlex
An AI in Education Conversation
Module 0390: How to use KDEnLive
Module 0391: A strategy to take Tak’s classes
Module 0392: How to submit TTPASM source code
Module 0393: The age of AI, STEM jobs, and study mindset
Module 0394: Cygwin-based riverSpider
Module 0395: CISP 310 Final Exam Explanations
Module 0396: Pre-semester Preparations
Module 0397: ARC CIS department policies, processes and procedures
Module 0398: Google Sheets GAS Coding, Debugging, Persistence, and UI
Module 0399: OER authoring using a command-line interface
Module 0400: A career in information and communication technology (ICT) or computer science (CS)
Module 0401: Intermediate note organization techniques using simple tools
AI and education
Module 0403: Extended RTL to denote C concepts at a low level
Module 0404:
Module 0405: A geek’s guide to closing the DI gap
Module 0406: Prerequisite and/or corequisite requirements
Module 0407: Preparing for a new semester
lost module mm0001!