Cse Curriculum 1

Computer Science
and Engineering
A comprehensive list of the courses I have covered across top universities that map to a
degree-equivalent in Computer Science and Engineering.
Nathan Moses
MOS Transistors
Columbia University 11 weeks
Faculty: Yannis Tsividis
Description:
Learn how MOS transistors work, and how to model them. The understanding provided in this
course is essential not only for device modelers, but also for designers of high-performance
circuits.
Syllabus:
- About This Course and Overview of the MOS Transistor
Welcome to the “MOS Transistors” course! We are very excited to be able to offer this course, and
are looking forward to working with you.
- The Two-Terminal and Three-Terminal MOS Structures
- The Long-Channel MOS Transistor – Part 1

This is the first module we are dealing with the complete transistor; much of this material, as
well as next module's material, will form the core of what we will be covering in the rest of the
course. We hope you will spend extra time studying to make sure you understand this material
in depth. The total viewing time in each of these two modules is shorter, which should help.
- The Long-Channel MOS Transistor – Part 2

This material concludes the lectures on the long-channel transistor in DC operation. As
mentioned earlier, these lectures will form the core on which many of our subsequent
discussions will be based.
- Small-Dimension Effects 1
In this module we are dealing with phenomena that occur when the transistor dimensions are
made small; this is important knowledge to have when one is dealing with modern devices.
- Small-Dimension Effects 2; Modeling for Circuits Simulation

This module will finish with small dimension effects, and then talk about models for circuit
simulation (the circuit designers among you are probably already using such models). We
discuss what it takes to make a good model for circuit simulation (among other things: a lot of
caution and care, and about 20,000 lines of code!), and how you can spot possible problems
with such models. Although models for circuit simulation include capabilities we have not yet
discussed, such as charge modeling, we think you know enough about models at this point to
be able to follow this general discussion (which is out of sequence – it’s from Chap. 10 in the
book, where you can find much more on the subject).
2
- Large-Signal Dynamic Operation
In this module there is a significant departure from what we have done up to this point: we will
allow the terminal voltages of the transistor to vary with time. We will determine the resulting
terminal currents, which will now include a “charging” component. We will do this both for
moderate and for very high “speeds”. The transient response of circuits involves similar
calculations, only done by computer for an ensemble of transistors and other devices.
- Small-Signal Modeling I
The material for this module deals with small-signal modeling and constitutes an important
part of the description of MOS transistor behavior. It relates small changes in terminal voltages
to the resulting small changes in currents. Small-signal modeling is key to analog circuit design,
but not only; it is also used in high-performance digital circuit design (e.g., in designing memory
sense amplifiers).
- Small-Signal Modeling II
This material concludes our discussion of small-signal modeling; it shows how we can model the
transistor at frequencies at which the simple model we derived last week is not valid. Such
modeling is important in high-frequency applications, e.g. transceiver design.
3
Linear Circuits 1: DC Analysis
Georgia Institute of Technology 7 weeks
Faculty: Bonnie H. Ferri, Joyelle Harris
Description:
This course explains how to analyze circuits that have direct current (DC) current or voltage
sources. A DC source is one that is constant. Circuits with resistors, capacitors, and inductors
are covered, both analytically and experimentally. Some practical applications in sensors are
demonstrated.
Syllabus:
- Module 1: Introduction
This module reviews background material from physics on the basic properties of
electricity and electrical circuits.
- Module 2
The module describes some basic principles used in circuit analysis.
- Module 3
This module demonstrates physical resistive circuits and introduces several systematic
ways to solve circuit problems.
- Module 4
This module introduces additional methods for analyzing circuit problems and how
resistors are used in sensors.
- Module 5
This module introduces capacitors and inductors, which are called "reactive" circuit
elements.
- Module 6
This module introduces the transient response behavior of RC and RL circuits after a
switch in a circuit is changed.
- Module 7
This module demonstrates useful applications of capacitors and inductors in real
engineering systems and introduces the behavior of second-order reactive circuits.
4
Linear Circuits 2: AC Analysis
Georgia Institute of Technology 5 weeks
Faculty: Bonnie H. Ferri, Joyelle Harris
Description:
This course explains how to analyze circuits that have alternating current (AC) voltage or current
sources. Circuits with resistors, capacitors, and inductors are covered, both analytically and
experimentally. Some practical applications in sensors are demonstrated.
Syllabus:
- Module 1: AC Circuit Analysis
- Module 2: Frequency Response
- Module 3: Filters
- Module 4: Power
- Module 5: Transformers
5
CS50's Introduction to Computer
Science
Harvard University 12 weeks
Faculty: Dr. David J. Malan, Doug Lloyd, Brian Yu
Description:
An entry-level course taught by David J. Malan, CS50x teaches students how to think
algorithmically and solve problems efficiently. Topics include abstraction, algorithms, data
structures, encapsulation, resource management, security, software engineering, and web
development. Languages include C, Python, SQL, and JavaScript plus CSS and HTML. Problem
sets inspired by real-world domains of biology, cryptography, finance, forensics, and gaming. The
on-campus version of CS50x , CS50, is Harvard's largest course. You’ll learn:
● A broad and robust understanding of computer science and programming.

● How to think algorithmically and solve programming problems efficiently.
● Concepts like abstraction, algorithms, data structures, encapsulation, resource
management, security, software engineering, and web development.
● Familiarity in a number of languages, including C, Python, SQL, and JavaScript plus CSS
and HTML.
● How to engage with a vibrant community of like-minded learners from all levels of
experience.
● How to develop and present a final programming project to your peers.
You’ll learn:
- Week 0: Scratch
Computer Science. Computational Thinking. Problem Solving: Inputs, Outputs.
Representation: Unary, Binary, Decimal, ASCII, Unicode, RGB. Abstraction. Algorithms.
Running Times. Pseudocode. Scratch: Functions, Arguments, Return Values; Variables;
Boolean Expressions, Conditionals; Loops; Events; Threads.
- Week 1: C
C. Source Code. Machine Code. Compiler. Correctness, Design, Style. Visual Studio Code.
Syntax Highlighting. Escape Sequences. Header Files. Libraries. Manual Pages. Types.
Conditionals. Variables. Loops. Linux. Graphical User Interface (GUI). Command-Line
Interface (CLI). Constants. Comments. Pseudocode. Operators. Integer Overflow.
Floating-Point Imprecision.
- Week 2: Arrays
6
Preprocessing. Compiling. Assembling. Linking. Debugging. Arrays. Strings.
Command-Line Arguments. Cryptography.
- Week 3: Algorithms
Searching: Linear Search, Binary Search. Sorting: Bubble Sort, Selection Sort, Merge Sort.
Asymptotic Notation: O,Ω,θ. Recursion.
- Week 4: Memory
Pointers. Segmentation Faults. Dynamic Memory Allocation. Stack. Heap. Buffer Overflow.
File I/O. Images.
- Week 5: Data Structures

Abstract Data Types. Queues, Stacks. Linked Lists. Trees, Binary Search Trees. Hash Tables.
Tries.
- Week 6: Python
Python: Functions, Arguments, Return Values; Variables; Boolean Expressions, Conditionals;
Loops. Modules, Packages.
- Week 7: SQL
SQL: Tables; Types; Statements; Constraints; Indexes; Keywords, Functions; Transactions.
Race Conditionals. SQL Injection Attacks.
- Week 8: HTML, CSS, JavaScript

Internet: Routers; TCP/IP; DNS. HTTP: URLs, GET, POST. HTML: Tags; Attributes. Servers. CSS:
Properties; Selectors. Frameworks. JavaScript: Variables; Conditionals; Loops. Events.
- Week 9: Flask
Flask. Route. Decorators. Requests, Responses. Sessions. Cookies.
- Week 10: Emoji

Precision. Unicode: Emoji, Code Points, ZWJ.
7
CS50's Introduction to Game
Development
Faculty: Dr. David J. Malan, Colton Ogden
Description:
In a quest to understand how video games themselves are implemented, you'll explore the
design of such childhood games via lectures and hands-on projects, the course explores
principles of 2D and 3D graphics, animation, sound, and collision detection using frameworks
like Unity and LÖVE 2D, as well as languages like Lua and C#. By class’s end, you'll have
programmed several of your own games and gained a thorough understanding of the basics of
game design and development.
Syllabus:
- Super Mario Bros.
- Pong
- Flappy Bird
- Breakout
- Match 3
- Legend of Zelda
- Angry Birds
- Pokémon
- 3D Helicopter Game
- Dreadhalls
- Portal
8
CS50's Mobile App Development
with React Native
Faculty: Dr. David J. Malan, Jordan Hayashi
Description:
Learn about mobile app development with React Native, a popular framework maintained by
Facebook that enables cross-platform native apps using JavaScript without Java or Swift.
Syllabus:
This course picks up where CS50 leaves off, transitioning from web development to mobile app
development with React Native. The course introduces you to modern JavaScript (including ES6
and ES7) as well as to JSX, a JavaScript extension. Through hands-on projects, you'll gain
experience with React and its paradigms, app architecture, and user interfaces. The course
culminates in a final project for which you'll implement an app entirely of your own design. You’ll
learn:
- JavaScript
- ES6
- React, JSX
- Components, Props, State, Style
- Components, Views, User Input
- Debugging
- Data
- Navigation
- Expo Components
- Redux
- Performance
- Shipping, Testing
9
CS50’s Web Programming with
Python and JavaScript
Faculty: Dr. David J. Malan, Brian Yu
Description:
This course picks up where CS50 leaves off, diving more deeply into the design and
implementation of web apps with Python, JavaScript, and SQL using frameworks like Django,
React, and Bootstrap.
Topics include database design, scalability, security, and user experience. Through hands-on
projects, you'll learn to write and use APIs, create interactive UIs, and leverage cloud services like
GitHub and Heroku. By course's end, you'll emerge with knowledge and experience in principles,
languages, and tools that empower you to design and deploy applications on the Internet.
You’ll learn:
You’ll learn:
- HTML, CSS
- Git
- Python
- Django
- SQL, Models, and Migrations
- JavaScript
- User Interfaces
- Testing, CI/CD
- Scalability and Security
10
CS50's Understanding Technology
Faculty: Dr. David J. Malan
Description:
This is CS50’s introduction to technology for students who don’t (yet!) consider themselves
computer persons.
This is CS50's introduction to technology for students who don’t (yet) consider themselves
computer persons. Designed for those who work with technology every day but don’t
necessarily understand how it all works underneath the hood or how to solve problems when
something goes wrong, this course fills in the gaps, empowering you to use and troubleshoot
technology more effectively. Through lectures on hardware, the Internet, multimedia, security,
programming, and web development, this course equips you for today’s technology and
prepares you for tomorrow’s as well.
You’ll learn:
- Internet
- Multimedia
- Security
- Web development
- Programming
11
CS50's Computer Science for
Business Professionals
Faculty: Dr. David J. Malan
Description:
This is CS50’s introduction to computer science for business professionals, designed for
managers, product managers, founders, and decision-makers more generally. Whereas CS50
itself takes a bottom-up approach, emphasizing mastery of low-level concepts and
implementation details thereof, this course takes a top-down approach, emphasizing mastery of
high-level concepts and design decisions related thereto. Through lectures on computational
thinking, programming languages, internet technologies, web development, technology stacks,
and cloud computing, this course empowers you to make technological decisions even if you
are not a technologist yourself. You’ll emerge from this course with first-hand appreciation of
how it all works and all the more confident in the factors that should guide your
decision-making..
You’ll learn:
- Computational thinking
- Programming languages
- Internet technologies
- Web development
- Technology stacks
- Cloud computing
12
Build a Modern Computer from First
Principles: From Nand to Tetris
Hebrew University of Jerusalem 6 weeks
Faculty: Shimon Schocken, Noam Nisan
Description:
What you’ll achieve:
In this project-centered course* you will build a modern computer system, from the ground up.
We’ll divide this fascinating journey into six hands-on projects that will take you from
constructing elementary logic gates all the way through creating a fully functioning general
purpose computer. In the process, you will learn - in the most direct and constructive way - how
computers work, and how they are designed.
What you’ll need:

This is a self-contained course: all the knowledge necessary to succeed in the course and build
the computer system will be given as part of the learning experience. Therefore, we assume no
previous computer science or engineering knowledge, and all learners are welcome aboard. You
will need no physical materials, since you will build the computer on your own PC, using a
software-based hardware simulator, just like real computers are designed by computer
engineers in the field. The hardware simulator, as well as other software tools, will be supplied
freely after you enroll in the course.
*About Project-Centered Courses: Project-centered courses are designed to help you complete a
personally meaningful real-world project, with your instructor and a community of learners with
similar goals providing guidance and suggestions along the way. By actively applying new
concepts as you learn, you’ll master the course content more efficiently; you’ll also get a head
start on using the skills you gain to make positive changes in your life and career. When you
complete the course, you’ll have a finished project that you’ll be proud to use and share.
Syllabus:
Course format:
The course consists of six modules, each comprising a series of video lectures, and a project. You
will need about 2-3 hours to watch each module's lectures, and about 5-10 hours to complete
each one of the six projects. The course can be completed in six weeks, but you are welcome to
take it at your own pace. You can watch a TED talk about this course by Googling "nand2tetris
TED talk".
- Introduction
Course introduction and overview, the roles of abstraction and implementation in systems design,
the road ahead.
13
- Boolean Functions and Gate Logic
We will start with a brief introduction of Boolean algebra, and learn how Boolean functions can be
physically implemented using logic gates. We will then learn how to specify gates and chips using
a Hardware Description Language (HDL), and how to simulate the behavior of the resulting chip
specifications using a hardware simulator. This background will set the stage for Project 1, in which
you will build, simulate, and test 15 elementary logic gates. The chipset that you will build this
module will be later used to construct the computer's Arithmetic Logic Unit (ALU) and memory
system. This will be done in modules 2 and 3, respectively.
- General Course Information
- Boolean Arithmetic and the ALU

Using the chipset that we've built in the previous module, we will now proceed to build a family of
adders -- chips designed to add numbers. We will then take a big step forward and build an
Arithmetic Logic Unit. The ALU, which is designed to perform a whole set of arithmetic and logical
operations, is the computer's calculating brain. Later in the course we will use this ALU as the
centerpiece chip from which we will build the computer's Central Processing Unit, or CPU. Since
all these chips operate on binary numbers (0's and 1's), we will start this module with a general
overview of binary arithmetic, and only then delve into building the ALU.
- Memory
Having built the computer's ALU, this module we turn to building the computer's main memory
unit, also known as Random Access Memory, or RAM. This will be done gradually, going bottom-up
from elementary flip-flop gates to one-bit registers to n-bit registers to a family of RAM chips.
Unlike the computer's processing chips, which are based on combinational logic, the computer's
memory logic requires a clock-based sequential logic. We will start with an overview of this
theoretical background, and then move on to build our memory chipset.
- Machine Language
A critically important aspect of building a new computer system is designing the low-level
machine language, or instruction set, with which the computer can be instructed to do various
things. As it turns out, this can be done before the computer itself is actually built. For example, we
can write a Java program that emulates the yet-to-be-built computer, and then use it to emulate
the execution of programs written in the new machine language. Such experiments can give us a
good appreciation of the bare bone "look and feel" of the new computer, and lead to decisions
that may well change and improve both the hardware and the language designs. Taking a similar
approach, in this module we assume that the Hack computer and machine language have been
built, and write some low-level programs using the Hack machine language. We will then use a
supplied CPU Emulator (a computer program) to test and execute our programs. This experience
will give you a taste of low-level programming, as well as a solid hands-on overview of the Hack
computer platform.
14
Modern Robotics, Course 1:
Foundations of Robot Motion
Northwestern University 4 weeks
Faculty: Kevin Lynch
Description:
Do you want to know how robots work? Are you interested in robotics as a career? Are you
15
willing to invest the effort to learn fundamental mathematical modeling techniques that are
used in all subfields of robotics?
If so, then the "Modern Robotics: Mechanics, Planning, and Control" specialization may be for
you. This specialization, consisting of six short courses, is serious preparation for serious
students who hope to work in the field of robotics or to undertake advanced study. It is not a
sampler.
In Course 1 of the specialization, Foundations of Robot Motion, you will learn fundamental
material regarding robot configurations, for both serial robot mechanisms and robots with
closed chains. You will learn about configuration space (C-space), degrees of freedom, C-space
topology, implicit and explicit representations of configurations, and holonomic and
nonholonomic constraints. You will also learn how to represent spatial velocities and forces as
twists and wrenches. This material is at the core of the study of anything that moves (e.g.,
robots).
This course follows the textbook "Modern Robotics: Mechanics, Planning, and Control" (Lynch
and Park, Cambridge University Press 2017). You can purchase the book or use the free preprint
pdf. You will build on a library of robotics software in the language of your choice (among
Python, Mathematica, and MATLAB) and use the free cross-platform robot simulator V-REP,
which allows you to work with state-of-the-art robots in the comfort of your own home and with
zero financial investment
Syllabus:
- Introduction to Modern Robotics

Introduction to the specialization, the Modern Robotics code library, the CoppeliaSim robot
simulator, and the lightboard video-generation tool.
- Chapter 2: Configuration Space (Part 1 of 2)

Configuration space and degrees of freedom of rigid bodies and robots.
- Chapter 2: Configuration Space (Part 2 of 2)

Configuration space topology and representation; configuration and velocity constraints;
task space and workspace.
- Chapter 3: Rigid-Body Motions (Part 1 of 2)
Rigid-body motions, rotation matrices, angular velocities, and exponential coordinates of
rotation.
- Chapter 3: Rigid-Body Motions (Part 2 of 2)

Homogeneous transformation matrices, twists, screws, exponential coordinates of rigid-body
motion, and wrenches.
16
Robot Kinematics
Description:
In Course 2 of the specialization, Robot Kinematics, you will learn to solve the forward
kinematics (calculating the configuration of the "hand" of the robot based on the joint values)
using the product-of-exponentials formula. Your efforts in Course 1 pay off handsomely, as
forward kinematics is a breeze with the tools you've learned. This is followed by velocity
kinematics and statics relating joint velocities and forces/torques to end-effector twists and
wrenches, inverse kinematics (calculating joint values that achieve a desired "hand"
configuration), and kinematics of robots with closed chains.
17
Syllabus:
- Chapter 4: Forward Kinematics
Product of exponentials formula for forward kinematics in the space frame and the
end-effector frame.
- Chapter 5: Velocity Kinematics and Statics
Velocity kinematics using the space Jacobian and body Jacobian, statics of open chains,
singularities, and manipulability.
- Chapter 6: Inverse Kinematics
Analytical and numerical inverse kinematics.
- Chapter 7: Kinematics of Closed Chains
Forward kinematics, inverse kinematics, velocity kinematics, and statistics of closed
chains.

Robot Dynamics
Description:
In Course 3 of the specialization, Robot Dynamics, you will learn efficient numerical algorithms
for forward dynamics (calculating the robot's acceleration given its configuration, velocity, and
joint forces and torques) and inverse dynamics (calculating the required joint forces and torques
given the robot's configuration, velocity, and acceleration). The former is useful for simulation,
and the latter is useful for robot control. You will also learn how to plan robot trajectories subject
to dynamic constraints.
This course follows the textbook "Modern Robotics: Mechanics, Planning, and Control" (Lynch
and Park, Cambridge University Press 2017). You can purchase the book or use the free preprint
pdf. You will build on a library of robotics software in the language of your choice (among
Python, Mathematica, and MATLAB) and use the free cross-platform robot simulator V-REP,
which allows you to work with state-of-the-art robots in the comfort of your own home and with
zero financial investment
18
Syllabus:
- Chapter 8: Dynamics of Open Chains (Part 1 of 2)

Lagrangian formulation of dynamics, centripetal and Coriolis forces, robot mass matrix,
dynamics of a rigid body, and Newton-Euler inverse dynamics for an open-chain robot.
- Chapter 8: Dynamics of Open Chains (Part 2 of 2)
Forward dynamics of an open chain, task-space dynamics, constrained dynamics, and
practical effects due to gearing and friction
- Chapter 9: Trajectory Generation (Part 1 of 2)
Point-to-point "straight-line" trajectories and polynomial trajectories passing through via
points
- Chapter 9: Trajectory Generation (Part 1 of 2)
Point-to-point "straight-line" trajectories and polynomial trajectories passing through via
points.
Modern Robotics, Course 4: Robot

Motion Planning and Control
Description:
In Course 4 of the specialization, Robot Motion Planning and Control, you will learn key concepts
of robot motion generation: planning a motion for a robot in the presence of obstacles, and
real-time feedback control to track the planned motion. Chapter 10, Motion Planning, of the
"Modern Robotics" textbook covers foundational material like C-space obstacles, graphs and
trees, and graph search, as well as classical and modern motion planning techniques, such as
grid-based motion planning, randomized sampling-based planners, and virtual potential fields.
Chapter 11, Robot Control, covers motion control, force control, and hybrid motion-force control.
19
Syllabus:
Chapter 10: Motion Planning (Part 1 of 2)

C-space obstacles, graphs and trees, and A* graph search.
Chapter 10: Motion Planning (Part 2 of 2)

Motion planning on a discretized C-space grid, randomized sampling-based planners, virtual
potential fields, and nonlinear optimization.
Chapter 11: Robot Control (Part 1 of 2)

First- and second-order linear error dynamics, stability of a feedback control system, and motion
control of robots when the output of the controller commands joint velocities.
Chapter 11: Robot Control (Part 2 of 2)

Motion control of robots when the output of the controller commands joint torques, force control,
and hybrid motion-force control.
Computer Architecture
Northwestern University
Faculty: David Wentzlaff
Description:
In this course, you will learn to design the computer architecture of complex modern
microprocessors.
Syllabus:
Introduction, Instruction Set Architecture, and Microcode
This lecture will give you a broad overview of the course, as well as the description of
architecture, micro-architecture and instruction set architectures.
- Pipelining Review
This lecture covers the basic concept of pipeline and two different types of hazards.
- Cache Review
20
This lecture covers control hazards and the motivation for caches.
- Superscalar 1
This lecture covers cache characteristics and basic superscalar architecture.
- Superscalar 2 & Exceptions

This lecture covers the common issues for superscalar architecture.
- Superscalar 3
This lecture covers different kinds of architectures for out-of-order processors.
- Superscalar 4
This lecture covers the common methods used to improve the performance of out-of-order
processors including register renaming and memory disambiguation.
- VLIW 1
This lecture covers the basic concept of very long instruction word (VLIW) processors.
Databases : Semistructured Data*

Stanford University 2 weeks
Faculty: Jennifer Widom
Description:
This course covers the JSON and XML standards for semistructured data, along with query
languages and schema declaration features for XML.
Syllabus:
- The XML Data section of this course introduces the XML model for semistructured and
self-describing data, including DTDs and some features of XML Schema.
- The JSON Data section of this course introduces the JSON model for human-readable
structured or semistructured data.
- The XPath and XQuery section of this course covers the XPath language for processing
XML data, along with many features of the more advanced XQuery language.
- The XSLT section of this course provides a general introduction to the XSLT rule-based
language for querying and transforming XML data.
21
You’ll Learn:
- The XML model for semistructured and self-describing data, including DTDs and some
features of XML Schema
- The JSON model for human-readable structured or semistructured data
- The XPath language for processing XML data, and many features of the more advanced
XQuery language
- An introduction to the XSLT rule-based language for querying and transforming XML
data.
*When I completed this online content, each section of this course was represented
separately as each its own “course”. It has since been consolidated.
Databases: Modeling and Theory*

Description:
This course covers underlying principles and design considerations related to databases; it can
be taken either before or after taking other courses in the Databases series.
22
Syllabus:
- The Relational Algebra section of this course teaches the algebraic query language
that provides the formal foundations of SQL.
- The Relational Design Theory section of the course provides comprehensive coverage
of dependency theory and normal forms in relational databases, a well-accepted
theoretical framework for developing good relational database schemas.
- The Unified Modeling Language section of this course introduces the data-modeling
component of UML, and describes how UML diagrams are translated to relational
database schemas.
You’ll Learn:
- Relational algebra – the algebraic query language that provides the formal foundations
of SQL.
- Dependency theory and normal forms in relational databases as the basis of schema
design
- The data-modeling component of the Unified Modeling Language (UML), how UML
diagrams are translated to relations
Databases: Relational Databases and SQL*

Description:
This course provides an introduction to relational databases and comprehensive coverage of

SQL, the long-accepted standard query language for relational database systems
23
You’ll learn:
- Introduction to the relational model and concepts in relational databases and relational
database management systems.
- Comprehensive coverage of SQL, the long-accepted standard query language for
relational database management systems.
24
Databases: Advanced Topics in SQL*
Description:
This course is broad and practical, covering indexes, transactions, constraints,
triggers, views, and authorization, all in the context of relational database
systems and the SQL language. This course builds on concepts introduced in
Databases: Relational Databases and SQL and is recommended for learners
seeking to advance their understanding and use of relational databases.
Syllabus:
- The Indexes and Transactions section of this course covers two important features of
database systems from the application builder's perspective: indexing for increased
performance, and transactions for concurrency control and failure recovery.
- The Constraints and Triggers section of this course explains key, referential integrity, and
"check" constraints, followed by comprehensive coverage of database triggers.
- The Views and Authorization section of this course provides extensive coverage of how
database views can be created, used, and updated, and introduces standard techniques
for authorization in relational databases.
You’ll learn:
- Creating indexes for increased query performance

- Using transactions for concurrency control and failure recovery
- Database constraints: key, referential integrity, and "check" constraints
- Database triggers
- How views are created, used, and updated in relational databases
- Authorization in relational databases.
25
Databases: OLAP and Recursion*
Description:
This course builds on concepts introduced in Databases: Relational Databases and SQL and is
recommended for learners seeking to understand On-Line Analytical Processing (OLAP) and/or
recursion in the SQL language.
Syllabus:
- The On-Line Analytical Processing section of this course introduces star schemas, the
data cube concept, and OLAP features in relational databases including the Cube and
Rollup operators.
- The Recursion section of this course covers the SQL standard for queries over
recursively-defined relations.
You’ll learn:
- Star schemas, the data cube concept, and On-Line Analytical Processing (OLAP) features
in relational databases including the Cube and Rollup operators
- The SQL standard for queries over recursively-defined relations.
26
Introduction to Embedded Systems
Software and Development
Environments
University of Colorado Boulder 4 weeks
Faculty: Alex Fosdick
Description:
This course is focused on giving you real-world coding experience and hands-on project work
with ARM-based Microcontrollers. You will learn how to implement software configuration
management and develop embedded software applications. Course assignments include
creating a build system using the GNU Toolchain GCC, using Git version control, and developing
software in Linux on a Virtual Machine. The course concludes with a project where you will
create your own build system and firmware that can manipulate memory.
Syllabus:
- Embedded System Development Components
Module 1 will introduce the learner to the components of your embedded system
software development process. This module will be a quick overview for many topics
with detailed analysis to follow in later modules and courses. We start with defining the
hardware and software building blocks of Embedded Systems which will include a
C-programming refresher. Next, you will learn about the important tools a developer will
need to use to help design, build and manage their designs. This includes development
environments, version control and the hardware kits to install on. Learners will install and
use a Virtual machine to complete Week 1 Application Assignment.
- Compilation with GCC and GNU Make

Module 2 will introduce the learner to the software development build system. Most
software engineers are very knowledgeable about their build system as we need them
to translate our high-level software languages to our architecture-specific
implementations. There are some important platform and architecture concepts that
are introduced in the build system to help enforce good software design techniques.
Learners will create their own build systems and utilize build tools to analyze their
embedded software implementations.
- Memory Types, Segments and Management

Module 3 will begin to introduce important embedded concepts like the memory
27
systems in their design. Learners will understand how the software-to-hardware
mapping occurs for their designs including differentiating between your program code
and your program data. Memory systems have many platform and architecture
dependencies, and you will begin to learn about some of the fundamental concepts a
software engineer needs to know to utilize all parts of an embedded system’s memory.
- Final Assessment
During this week you are going to combine what you have learned in modules 1-3 to
write some memory manipulation software, incorporate it into your build system and
then run some test functions. At the end of the assignment you will perform a detailed
code review of other learners’ software. Reviewing other learners' code is very important
for both your growth of software design but also for the coder to gain valuable feedback.
Professional software engineers regularly go through software reviews when developing
code.
Embedded Software and

Hardware Architecture
28
Description:
Embedded Software and Hardware Architecture is a first dive into understanding embedded
architectures and writing software to manipulate this hardware. You will gain experience writing
low-level firmware to directly interface hardware with highly efficient, readable and portable
design practices. We will now transition from the Host Linux Machine where we built and ran
code in a simulated environment to an Integrated Development Environment where you will
build and install code directly on your ARM Cortex-M4 Microcontroller. Course assignments
include writing firmware to interact and configure both the underlying ARM architecture and
the MSP432 microcontroller platform. The course concludes with a project where you will
develop a circular buffer data structure.
In this course you will need the Texas Instruments LaunchPad with the MSP432 microcontroller
in order to complete the assignments. Later courses of the Specialization will continue to use
this hardware tool to develop even more exciting firmware.
Syllabus:
- Interfacing C-Programs with ARM Core Microcontrollers

Module 1 will introduce the learner to how software/firmware can interface with an
embedded platform and the underlying processor architecture. Embedded Software
engineers must be very knowledgeable about the architecture in order to write efficient
and bug free code. This requires knowledge of processor architecture. memory systems,
microcontroller peripherals and more advanced use of the compiler. This module will
continue to enforce good software design techniques with a focus on portability and
maintainability without reducing your hardware’s performance.
- Manipulating Memory
Module 2 will introduce the learner to more advanced firmware techniques as well move
us into some hands on firmware for the microcontroller. We start by building our own
memory access methods that will allow a programmer to manipulate peripheral
memory bit fields to configure microcontroller peripherals and core architecture
concepts. This will include more complex use of pointers for register definition files and
function pointers for interrupt vector tables The module concludes with an in-depth look
into the features of on-target debugging on a microcontroller and a hands-on example.

systems in their design. Learners will understand how the software to hardware
29
Input Filter Design

Faculty: Dr. Dragan Makismovic
Description:
After completion of this course, you will gain an understanding of issues related to
electromagnetic interference (EMI) and electromagnetic compatibility (EMC), the need for input
filters and the effects input filters may have on converter responses. You will be able to design
properly damped single and multi-section filters to meet the conducted EMI attenuation
requirements without compromising frequency responses or stability of closed-loop controlled
power converters.
After completing this course, you will be able to:
30
● Understand conducted electromagnetic interference (EMI) and the need for input filter
● Understand input filter design principles based on attenuation requirements and impedance
interactions.
● Design properly damped single-stage input filters.
● Design properly damped multi-stage input filters.
● Use computer-aided tools and simulations to verify input filter design.
Syllabus:
- Introduction to Input Filter Design

Introduction to electromagnetic interference, the need for input filtering, and the input
filter effects
- Single-Stage Input Filter Design

Design of single-section damped input filters
- Multi-Stage Input Filter Design

Design of multiple-section damped inputs filters
Sensors and Sensor Circuit Design

Faculty: James Zweighaft / Jay Mendelson
Description:
This course can also be taken for academic credit as ECEA 5340, part of CU Boulder’s Master of
Science in Electrical Engineering degree.
After taking this course, you will be able to:
- Understand how to specify the proper thermal, flow, or rotary sensor for taking real-time
process data.
- Implement thermal sensors into an embedded system in both hardware and software.
- Add the sensor and sensor interface into a microprocessor based development kit.
- Create hardware and firmware to process sensor signals and feed data to a
31
microprocessor for further evaluation.
- Study sensor signal noise and apply proper hardware techniques to reduce it to
acceptable levels.
- Use computer-aided tools and simulations to verify input filter design.
Syllabus:
- Thermal Sensors
In module 1 you will learn how to specify and use temperature sensors in an embedded circuit.
First, you will learn about common types of sensors and actuators found in common products
such as smartphones and automobiles. Then you will get a high-level overview of analog and
digital interfaces, followed by a deep dive into thermistors, RTD’s, and thermocouples. For each
of these three types of thermal sensors, we define the core theory and formulae, give you
examples of how commercial sensors are packaged, and explain what you need to know to
purchase them on a web site.
- Sensor Development Kit and Prototyping

In module 2 you will learn how to design a complete temperature sensor system within a
development kit environment. We will teach you how to assign internal components to the
schematic. This includes pins, amplifiers, MUX’s, DAC’s, and ADC’s. Then you will learn how to
wire in external parts: resistors, thermistors in particular, to the kit. Finally, you will take a deep
dive into interfacing a thermistor and associated front end components to the development kit.
This includes lessons on using the schematic portion of the kit, as well as writing application
software in c code.
- Rotary and Flow Sensors

In module 3 you will learn how rotary sensors work and how to specify them for purchase. In our
videos rotary sensors include both optical encoders and resolvers. You will also learn the design
intricacies of flow sensors, along with their appropriate applications. The videos will discuss
variable area, differential pressure, vortex, ultrasonic, turbine, thermal mass flow, and coriolis flow
meters.
- Amplifiers and Sensor Noise

In module 4 you will learn the theory and practical application of amplifiers and circuit noise.
You will review how gain is calculated in inverting, non-inverting, summing, differential, and
instrumentation amplifiers. We will then contrast theoretical vs. real-world amplifier
performance, and give examples of how commercial chips specs are interpreted. Then we will
discuss the causes of noise in sensor circuits, how the noise affects sensor accuracy, and some
steps you can take to reduce noise in your sensor circuit designs.
32
Motors and Motor Control
Circuits
Faculty: James Zweighaft, Jay Mendelson
Description:
This course can also be taken for academic credit as ECEA 5341, part of CU Boulder’s Master of
Science in Electrical Engineering degree.
This is our second course in our specialization on Embedding Sensor and Motors. To get the
most out of this course, you should first take our first course entitled Sensors and Sensor
Circuits. After taking this course, you will be able to:
- Understand how to specify the proper AC or DC motor for a machine design.

- Integrate the motor to a machine, based on analysis of motor equations for voltage,
current, torque and speed.
- Implement the motor and accompanying rotary sensor into a motor control circuit in
both hardware and software.
- Add a motor and motor control circuit into a microprocessor based development kit.
- Create hardware and firmware to process motor feedback data to a microprocessor for
further evaluation.
33
Syllabus:
- AC Motor Designs
In module 1 you will learn principles of operation of AC induction motors, both single and
3-phase types. You will then learn how to interpret data from torque speed curves, and how to
optimize data in these curves based on electrical resistance, inductance, and capacitance. Then
you will learn about different types of single phase motors, featuring a video analysis of a split
phase motor used in a clothing dryer. You will also learn about typical applications for single
phase motors, which will assist you in picking the right one for an application.
- AC Motor Control
In module 2 you will learn the details of AC motor specifications and enclosures, as well as how
these details are governed by national and international design standards. Then you will learn a
detailed methodology for researching design requirements for AC motors, and how to use these
requirements to pick the right motor for your needs. Afterwards, you will have lessons on AC
motor control components and systems, both manual and automatic. This will culminate in
training for you on AC variable speed drives.
- DC Motors
In module 3 you will learn principles of DC motors, traditional brushed motors, as well as
electronically driven brushless motors. We will discuss shunt wound, series wound, compound
wound, servo, stepper, and torque motors, with detailed explanation of how commutation and
control is implemented in these designs. We will have a lab exercise for you on DC motor speed
measurement. We will have another video analysis for you, this time featuring the teardown of a
paper shredder. Then you will learn a detailed methodology for researching design
requirements for DC motors, and how to use these requirements to pick the right motor for your
needs.
- DC Motor Control and Stepper Motors

In module 4 you will start off with another lab exercise, this time gaining hands-on experience
with DC motor control. Then, we will illustrate a simplified stepper motor drive, so you will
understand the basic principles involved in stepper motor control. Next, you will do a deep dive
into stepper motor specs, operation and commercial driver chips and packages. You will then do
another lab exercise, this time on actuating a rotary sensor. We end the module with a
comparison of DC vs. AC motors, so you take away a core understanding of their pros and cons.
34
Pressure, Force, Motion, and Humidity
Sensors
Faculty: James Zweighaft, Jay Mendelson
Description:
"Pressure, Force, Motion, and Humidity Sensors" can also be taken for academic credit as ECEA
5342, part of CU Boulder’s Master of Science in Electrical Engineering degree.
This is our third course in our specialization on Embedding Sensor and Motors. To get the most
out of this course, you should first take our first course entitled Sensors and Sensor Circuits. Our
first course gives you a tutorial on how to use the hardware and software development kit we
have chosen for the lab exercises. This third course assumes that you already know how to use
the kit.
- Understand how to specify the proper AC or DC motor for a machine design.

- Integrate the motor to a machine, based on analysis of motor equations for voltage,
current, torque and speed.
- Implement the motor and accompanying rotary sensor into a motor control circuit in
both hardware and software.
- Add a motor and motor control circuit into a microprocessor based development kit.
- Create hardware and firmware to process motor feedback data to a microprocessor for
further evaluation.
Syllabus:
- Pressure Sensors
In module 1 you will learn how to specify and use various types of pressure sensors for an
embedded circuit. First, you will learn about piezoresistive, capacitive, and vacuum sensors. This
includes a deep dive into the piezoresistive effect and how a Wheatstone bridge is used in these
systems. This is followed by a discussion on pressure transmitters and how to calculate an error
budget. Finally, we will give you examples of commercial pressure sensors and explain what you
need to know to purchase them on a web site.
35
- Force and Strain Sensors and Touch Screens
In module 2 you will learn how to specify and use various types of force and strain sensors for an
embedded circuit. First, you will learn about how strain gauges use the piezoresistive effect and
Wheatstone bridges to output a strain signal. Then you will learn how load cells use strain gauges
to output a force signal. We have a video on a teardown of a weight scale for you to watch, where
we teach you how the strain gauges are arranged in an unusual bridge circuit. Finally, we teach
you about how touch screens used in kiosks, PC's and smartphones work. We have a lab exercise
for you to perform on strain gauges, where you will get hands-on experience wiring the gauges
into the PSoC system, and writing code to read the gauges.
- Position, Acceleration and Velocity Sensors

In module 3 you will first learn how magnetic detection sensors such as Hall sensors and LVDT's
work, as well as how capacitive detection sensors work. Then you will learn how to specify and use
accelerometers in an embedded circuit. We will discuss how the first accelerometers used the
piezoelectric effect to output a sinusoidal signal. We will review the key principles and equations
involved in vibrational measurement. Then you will learn later accelerometers used the
piezoresistive effect and internal strain gauges to output a sinusoidal signal representative of force,
as opposed to acceleration. Then we will explain how accelerometers are now using MEMS
technology and changes in capacitive to output the signal. We teach you about gyroscopes, both
traditional mechanical ones, still used in aircraft for angular position sensing, and modern MEMS
ones used to determine angular velocity.
- Motion, Distance and Humidity Sensors

In module 4 you will learn how to specify and use position and motion detectors in an embedded
circuit. First, you will learn about the pyroelectric effect. Then you will learn how Passive Infrared
motion detectors use the pyroelectric effect in commercial burglar alarms. Then you will learn how
ultrasonic distance detection is accomplished, the same principles that whales, dolphins and bats
use to navigate their worlds. We tackle microwave detection sensors last, as these are the most
complex sensors that we cover in the course. They are used in long range position detection
sensors and commercial security sensors for outdoors use.
Sensor Manufacturing and Process

Control
Description:
"Sensor Manufacturing and Process Control" can also be taken for academic credit as ECEA
36
5343, part of CU Boulder’s Master of Science in Electrical Engineering degree.
This is our fourth course in our specialization on Embedding Sensors and Motors. To get the
most out of this course, you should first take our first course entitled "Sensors and Sensor
Circuits", our second course entitled "Motor and Motor Control Circuits", and our third course
entitled "Pressure, Force, Motion, and Humidity Sensors". Our first course gives you a tutorial on
how to use the hardware and software development kit we have chosen for the lab exercises.
Our second and third courses give you three hands-on lab experiments using the kit. This third
course assumes that you already know how to use the kit.
You will learn about sensor signal characterization and manufacturing techniques and how to
optimize the accuracy of sensors. You will also learn about more advanced sensors,
proportional-integral-derivative (PID) control, and how this method is used to give you a closed
loop sensor feedback system.
- Understand how sensor manufacturers characterize and calibrate their sensors.

- Tune a PID control loop and access the PID control function of the Cypress PSoC
development kit for a motor control application.
- Understand manufacturing methods used to build electro-mechanical and
micro-machined sensors.
Syllabus:
- Process Control
In module 1 you will learn how companies perform process control in their factories. First, you will
review how 2nd order transfer functions work, which is the theoretical basis for much of process
control. Then you will learn how plant-wide control systems are implemented and details about
the software protocols used to communicate between plant controllers and sensors. Then you will
perform a lab for PID control with your PSoC system, which will get you some hands-on
experience with this type of control system.
- Sensor Characterization
In module 2 you will learn how sensor software is adjusted for optimal performance in the field.
First, you will review how non-linear sensor response curves are linearized for more predictable
performance. Then you will learn how sensor output is automatically adjusted to account for wide
ranges of ambient temperature. Next, you will review how sensors are calibrated, and the
certification procedures that companies follow to demonstrate calibration capability. Afterwards,
you will study how linearization, compensation, and calibration play into sensor accuracy specs.
Finally, you will perform a lab for closed loop motor control with your PSoC system, which will get
you some hands-on experience with closed loop systems.
- Advanced Sensors
In module 3 you will first learn how radar level transmitters work, and how they are used to provide
accurate readings in all types of process tank conditions. Then you will learn about components
and design issues for LIDAR systems used in self driving vehicles. Afterwards, we will teach you
about how sensors are customized for medical applications. This includes pressure and
37
temperature sensors that are implanted during surgical procedures, as well as pressure and flow
sensors used in patient care equipment.
- Sensor Manufacturing
In module 4 you will learn how sensors are manufactured. First you will learn how MEMS
construction is used to make miniature flow, pressure, and temperature sensors. Afterwards, we
will teach you how micro-electronic connections attach the MEMS sensors to connections within
plastic encapsulated chips. Then we will discuss how sensor chips are enclosed within sensor
housings, and how different designs of housings are used for different applications. Then you will
learn how sensors are tested for high reliability in the field.
Introduction to Embedded Systems

Software and Development Environments
Description:
38
Syllabus:
- Embedded System Development Components

Module 1 will introduce the learner to the components of your embedded system
software development process. This module will be a quick overview for many topics
with detailed analysis to follow in later modules and courses. We start with defining the
hardware and software building blocks of Embedded Systems which will include a
C-programming refresher. Next, you will learn about the important tools a developer will
need to use to help design, build and manage their designs. This includes development
environments, version control and the hardware kits to install on. Learners will install and
use a Virtual machine to complete Week 1 Application Assignment.
- Compilation with GCC and GNU Make

Module 2 will introduce the learner to the software development build system. Most
software engineers are very knowledgeable about their build system as we need them
to translate our high-level software languages to our architecture-specific
implementations. There are some important platform and architecture concepts that
are introduced in the build system to help enforce good software design techniques.
Learners will create their own build systems and utilize build tools to analyze their

systems in their design. Learners will understand how the software-to-hardware
- Final Assessment
During this week you are going to combine what you have learned in modules 1-3 to
write some memory manipulation software, incorporate it into your build system and
then run some test functions. At the end of the assignment you will perform a detailed
code review of other learners’ software. Reviewing other learners' code is very important
for both your growth of software design but also for the coder to gain valuable feedback.
Professional software engineers regularly go through software reviews when developing
code.
39
Algorithms: Design and Analysis
Faculty: Tim Roughgarden
Description:
The course is rigorous but emphasizes the big picture and conceptual understanding over
low-level implementation and mathematical details. After completing this course, you will have
a greater mastery of algorithms than almost anyone without a graduate degree in the subject.
Syllabus:
Specific topics in the course include: "Big-oh" notation, sorting and searching, divide and
conquer (master method, integer and matrix multiplication, closest pair), randomized
algorithms (QuickSort, contraction algorithm for min cuts), data structures (heaps, balanced
search trees, hash tables, bloom filters), graph primitives (applications of BFS and DFS,
connectivity, shortest paths).
Learners will practice and master the fundamentals of algorithms through several types of
assessments. There are 6 multiple choice quizzes to test your understanding of the most
important concepts. There are also 6 programming assignments, where you implement one of
the algorithms covered in lecture in a programming language of your choosing. The course
concludes with a multiple-choice final. There are no assignment due dates and you can work
through the course materials and assignments at your own pace.
40
Algorithms: Design and Analysis 2
Faculty: Tim Roughgarden
Description:
Syllabus:
Specific topics in Part 2 include: greedy algorithms (scheduling, minimum spanning trees,
clustering, Huffman codes), dynamic programming (knapsack, sequence alignment, optimal
search trees, shortest paths), NP-completeness and what it means for the algorithm designer,
analysis of heuristics, local search.
Learners will practice and master the fundamentals of algorithms through several types of
assessments. There are 6 multiple-choice problem sets to test your understanding of the most
important concepts. There are also 6 programming assignments, where you implement one of
the algorithms covered in lecture in a programming language of your choosing. The course
concludes with a multiple-choice final.
41
Introduction to Computer Networking
Faculty: Phil Levis, Nick McKeown
Description:
The Internet drives tremendous change in the world while continuously changing and evolving
itself. This course teaches the concepts and general principles of the underlying networks of the
Internet.
Learn about the structure and components of computer networks, packet switching, and layer
architectures as well as a variety of applications. Gain the experience and tools required to use
and write protocols. Explore issues of network security.
You’ll learn:
- Web/http, voice-over-IP, p2p file sharing and socket programming

- Reliable transport: TCP/IP, reliable transfer, flow control, and congestion control
- The network layer: names and addresses, routing
- Local area networks: ethernet and switches
- Wireless networks and network security
- Learners will create their own build systems and utilize build tools to analyze their
42
Compilers
Faculty: Alex Aiken
Description:
You will learn how a program written in a high-level language designed for humans is
systematically translated into a program written in low-level assembly more suited to machines.
Along the way we will also touch on how programming languages are designed, programming
language semantics, and why there are so many different kinds of programming languages.
Syllabus:
The course lectures will be presented in short videos. To help you master the material, there will
be in-lecture questions to answer, quizzes, and two exams: a midterm and a final. There will also
be homework in the form of exercises that ask you to show a sequence of logical steps needed
to derive a specific result, such as the sequence of steps a type checker would perform to type
check a piece of code, or the sequence of steps a parser would perform to parse an input string.
This checking technology is the result of ongoing research at Stanford into developing
innovative tools for education, and we're excited to be the first course ever to make it available to
students.
An optional course project is to write a complete compiler for COOL, the Classroom Object
Oriented Language. COOL has the essential features of a realistic programming language, but is
small and simple enough that it can be implemented in a few thousand lines of code. Students
who choose to do the project can implement it in either C++ or Java.
43

Cse Curriculum 1

Uploaded by

Copyright:

Available Formats

You might also like

Cse Curriculum 1

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cse Curriculum 1

Uploaded by

Copyright:

Available Formats

Computer Science

Faculty: Yannis Tsividis

- The Two-Terminal and Three-Terminal MOS Structures

- The Long-Channel MOS Transistor – Part 1

- The Long-Channel MOS Transistor – Part 2

- Small-Dimension Effects 2; Modeling for Circuits Simulation

Georgia Institute of Technology 7 weeks

Faculty: Bonnie H. Ferri, Joyelle Harris

Faculty: Bonnie H. Ferri, Joyelle Harris

Faculty: Dr. David J. Malan, Doug Lloyd, Brian Yu

● A broad and robust understanding of computer science and programming.

- Week 5: Data Structures

- Week 8: HTML, CSS, JavaScript

- Week 10: Emoji

Faculty: Dr. David J. Malan, Colton Ogden

Faculty: Dr. David J. Malan, Jordan Hayashi

Faculty: Dr. David J. Malan, Brian Yu

Faculty: Dr. David J. Malan

Faculty: Dr. David J. Malan

Faculty: Shimon Schocken, Noam Nisan

What you’ll need:

- General Course Information

- Boolean Arithmetic and the ALU

Faculty: Kevin Lynch

- Introduction to Modern Robotics

- Chapter 2: Configuration Space (Part 1 of 2)

- Chapter 2: Configuration Space (Part 2 of 2)

- Chapter 3: Rigid-Body Motions (Part 2 of 2)

Faculty: Kevin Lynch

Modern Robotics, Course 3:

Faculty: Kevin Lynch

- Chapter 8: Dynamics of Open Chains (Part 1 of 2)

Modern Robotics, Course 4: Robot

Faculty: Kevin Lynch

Chapter 10: Motion Planning (Part 1 of 2)

Chapter 10: Motion Planning (Part 2 of 2)

Chapter 11: Robot Control (Part 1 of 2)

Chapter 11: Robot Control (Part 2 of 2)

Faculty: David Wentzlaff

- Superscalar 2 & Exceptions

Databases : Semistructured Data*

Faculty: Jennifer Widom

Databases: Modeling and Theory*

Faculty: Jennifer Widom

Databases: Relational Databases and SQL*

Faculty: Jennifer Widom

This course provides an introduction to relational databases and comprehensive coverage of

Faculty: Jennifer Widom

- Creating indexes for increased query performance

Faculty: Jennifer Widom

Faculty: Alex Fosdick

- Compilation with GCC and GNU Make

- Memory Types, Segments and Management

Embedded Software and

Faculty: Alex Fosdick

- Interfacing C-Programs with ARM Core Microcontrollers

- Memory Types, Segments and Management