# Profile

## Steven Frank

Student

**59**reviews**57**completed

"2x2 Systems of Differential Equations" wins the prize for most intimidatingly nerdy course title ever (though the trophy will pass to the NxN systems course when that one launches). While there's plenty of challenge in this course, the third installment in MIT's five-part tour of differential equations, there is nothing to be afraid of. Building on the earlier courses, this one treats pairs of differential equations, which, it turns out, opens whole new possibilities for their application. In pairs, differential equations can be used to simplify a higher-order equation, or more interestingly to model systems of interacting entities -- predator-prey populations, interconnected mixing tanks, and mechanical and electrical systems. Doing fancy bits of analysis such as creating "phase portraits" allows you to see how the system evolves from an arbitrary starting point, e.g., if you start with more wolves than deer, will the populations reach a stable equilibrium or will one or both populations go extinct? The instruction in this course is unsurpassed, as befits MIT, never soaring above your head. There are six lecture sequences, each including well-considered problems that solidify your understanding, and "recitation" problems that, while graded, can be discussed freely. Together these count as 20% of the grade. There are also three A and B problem sets; the B-set problems are substantially more challenging than the A-set problems and count more heavily toward the final grade. The also-challenging but doable final exam counts for 45% of the final grade, so you don't want to blow that one. Math nerds need no encouragement to take this course, but those like me who appreciate math more for what it lets you do than for its own sake will find this course edifying, tractable and rewarding.

Buckle up -- this deep, mathematically rigorous dive into the major areas of machine learning is fast-paced and challenging. In fact, most of the course is less about machine learning than the math behind it -- problem-solving and applications take a back seat to the underlying mathematical techniques. You won't see very many implementation examples or, in the programming projects, watch a machine get smarter. For that context, you either need prior ML training or to have taken the first course in the AI MicroMaster series, Artificial Intelligence with Ansaf Salleb-Aouissi, which treats most of the topics in this course at a higher, more introductory level. Also, considerable fluency in probability and statistics is assumed -- at the level of MITx 6.041, for example. Although no textbook is suggested, I found "The Elements of Statistical Learning" by Hastie et al. to be quite useful. The topics covered are numerous, too many to list without putting you to sleep, but they span all of the common machine learning techniques except neural networks, which is a subject in itself (and is nicely covered at a high level in the AI course). There are four programming projects, weekly quizzes, and a final exam that counts for a whopping 45% of your grade. Prof. Paisley's lectures are clear and deftly unpack difficult mathematical principles and derivations, although he speaks a bit slowly and I found that playing the lectures at 1.25x speed delivered a more natural cadence. All in all this is a great course, but be forewarned.

Stanford's "CS1 Compilers" is less a course than a way of life -- thank goodness it's self-paced! The experience is like being asked to translate a novel into a sequence of foreign languages you're learning for the first time. The amount of work is prodigious, and I haven't even started the programming assignments yet. But this course deserves its reputation as the best there is on the subject. The instructor, Alex Aiken, is fantastic. His articulate, conversational style is easy to follow and he assumes a minimal CS background, just C and exposure to assembly language. The course material is broadly organized around four key components of compiler design: syntax, parsing, semantics and type checking, and code generation.
So let's talk about the languages you'll learn. The language for which you'll be writing a compiler is COOL, the Classroom Object-Oriented Language written by Prof. Aiken. There's a tutorial, a reference manual, and some example programs, but ultimately this is a new C++/Java-like object-oriented programming language you'll have to learn. Then we're on to the computer science. Lexical analysis partitions a high-level program into its basic lexical components (keywords, numbers, etc.) using the languages of regular expressions and formal grammars. Regular expressions, in turn, are implemented computationally by finite automata, which have their own peculiar language. The first programming assignment, which has you writing a lexical analyzer, uses a framework called Flex or Jlex, depending on whether you're coding the assignments in C++ or Java (the only allowed choices) -- so that's another language. The next step, parsing, uses the language of context-free grammars, and here's where things get pretty theoretical -- think parse trees and Noam Chomsky. After you master the languages of top-down and bottom-up parsing, you can put them to work using a tool called bison (for C++) or CUP (for Java) -- so that's yet another language. Now we're into semantic analysis and type checking, which use the rigorous language of formal logic (think mathematical proofs) and abstract syntax trees. For the programming assignment, you'll write a semantic analyzer involving 1500-3000 lines of code. Code generation, the final stage of the compiler you'll write, requires a fairly deep dive into assembly language (the MIPS language, in particular), and the lectures lead you through the complexities of register and stack management. In the programming assignment, you write a code generator (another 1500-3000 lines of C++ or Java) that creates MIPS assembly code for the abstract syntax tree generated by your semantic analyzer.
Now, all of these programming assignments are actually optional. The mandatory assignments are six quizzes, which are difficult but allow unlimited attempts, and a midterm and final, which are killers and allow only one attempt at each question with no partial credit. But you'd be crazy not to at least attempt the programming assignments if you want to learn about compilers. This course is supremely well-taught and well-organized, and -- again -- mercifully self-paced. Just know what you're getting into and buckle up.

This course introduces you to the basics of robot movement as well as some of the cutting-edge issues in robot design. It's part of Columbia's Artificial Intelligence MicroMasters program, though it stands on its own as a primer on the practical guts of robotics -- the math of moving robot arms. A good background in linear algebra and vector calculus, and facility with Python programming, are essential. You'll learn how to work with the widely used Robot Operating System framework, which you're expected -- very reasonably, since this is an advanced-level computer science course -- to largely pick up on your own. There are four programming projects of increasing difficulty, two problem sets, and a final exam. The programming assignments mostly focus on getting a simulated robot arm to do what you want it to do, and that can be challenging -- what joint movements are necessary to get the arm from one "pose" to another? Not easy! Add some obstacles that have to be avoided and the challenge grows. Professor Ciocarlie is an excellent lecturer, deftly guiding you through the math and the algorithmic strategies, and also providing very worthwhile perspectives on what robots can do now and where the research is headed. The course is well-staffed, and the resources (including online programming environments and a downloadable virtual machine so you can implement locally) work well and are mostly glitch-free. Overall, an excellent and rigorous introduction to the heart of robotics.

This final installment of the Computation Structures sequence begins with processor pipelining and optimization, subjects that extend the material presented in part 2 of the class, and then moves on to operating systems, virtualization, parallel processing and inter-processor communication. The capstone project for this course segment is optimization of the Beta processor constructed in part 2. It is a lab like no other. Scoring even a few points requires a substantial amount of work and understanding of processor operation (which you thought you knew, but didn't really) and optimization strategies, which can be challenging to implement. The discussion board lights up with ideas, suggestions, guidance and kvetches. Never will you feel more like an MIT student than when you tackle this immensely rewarding project. The other labs in this segment, while somewhat overshadowed by the Big Kahuna, are outstanding in their own right. One of them has you optimizing a time-share operating system, which, along with the always-excellent lectures, provides a great deal of knowledge about how modern operating systems work.
The Computation Structures course sequence teaches computers from the ground up -- from transistors to digital building blocks to processors to the art of optimization. The knowledge you gain is like an adjustable telescope that lets you think about computer operation at whatever level of abstraction is appropriate to the task. The 6.003x course sequence stands as the definitive overview of the technology that powers an ever-increasing fraction of our daily lives -- iPhones, cars, smart refrigerators and, who knows, maybe the shirt you'll soon be wearing all use microprocessors built from digital circuits and interact with users via operating systems and communication networks, and after completing 6.003x, you'll understand their inner workings and appreciate the engineering challenges facing their designers.

It's really nerdy. It's profoundly math-y. It's quite challenging, often mind-bendingly so. And it is, without a doubt, the best-taught, most comprehensive probability course out there or even imaginable. Over 16 fast-paced weeks, this course covers every major topic in probability and zips through statistics for good measure. The syllabus includes combinatorics, conditional probability and Bayes' Rule, random variables of many types, expectation and variance, covariance and correlation, error and estimation, the law of large numbers and the Central Limit Theorem, Poisson and Bernoulli processes, and Markov chains. There are weekly problem sets, two midterm-like exams and a final, and graded in-lecture exercises. Expect to spend 10 to 15 hours a week on the course. The lectures are given primarily by Prof. Tsitsiklis, but for each unit there is also an ESSENTIAL sequence of (ungraded) solved problems taught by a team of extremely talented TAs. These and the in-lecture exercises, which count for a small fraction of the grade, really provide the intellectual framework for the problem sets and exams. Don't skip them, and even if you got an answer right, read the provided solutions! The rigorous, often abstract thought processes needed to succeed with the material are not natural -- you really have to train your mind to work in new ways, and the exercises and solved problems show the way. The staff is enthusiastic and responsive; while some MOOCs enter a kind of zombie mode after the first couple of sessions, this one retains the energy of a brand-new offering.
If I have one modest complaint about the course, it's the relentlessly theoretical perspective. To me, probability problems take on life when they're about batting averages, the spread of disease, and stochastic phenomena in nature. In this course, most of the problems involve cards, coins, and characters named Alice and Bill. You may be charmed by esoteric distinctions between numbers and random variables, but i could have used a little more Moneyball. This, however, is a minor quibble. The material is foundational and supremely valuable across innumerable scientific and technical disciplines. Make the necessary time and devote the required effort, and the rewards will more than compensate.

Is it possible to bring a hands-on residential course in manufacturing techniques to a hands-off online audience? MIT Prof. John Hart thinks so, and it's difficult to imagine a better effort than MITx 2.008. The course covers machining, injection molding, thermoforming (think Halloween masks), sheet metal work, casting, and 3D printing. There are broad-themed units on variation and quality, cost, the role of robotics, sustainability and climate change, and a wrap-up on the future of manufacturing. Each unit includes a series of lectures with (graded) online exercises and a quiz; there is no final or midterm exam.
Substituting for the hands-on lab work are videos mostly featuring MIT's David Dow, who runs their machine shop and knows his tools inside and out -- and as a technical instructor is quite engaging and articulate in demonstrating how they work. There are also videos of industrial-scale manufacturing machines at work, and these are fabulous: auto-assembly robots dancing a spidery ballet, building-scale blow-molders making Hefty garbage bags, busy milling machines carving iPhone cases. You really do get a feel for how these things work, their limits and what can go wrong. The units on cost, variation and quality are extremely valuable, analyzing the economics and complications of scaling production for a mass market.
The exercises and homework ranged from easy to quite challenging, and not always in a good way. The best questions required an intellectual stretch; others were needlessly tricky, or offered equally plausible answers (only one of which was accepted), or went clearly beyond the lecture material, or seemed too hard without prior exposure to the material. But the minimum passing score is low and not difficult to attain if you pay attention and think.
These quibbles aside, 2.008x is an enjoyable and valuable course with first-rate lectures, eclectic and well-chosen topics, and a lot of cool videos.

Of longstanding renown in the MOOC world, Stanford's machine learning course really is the definitive introduction to this topic. The course broadly covers all of the major areas of machine learning -- linear and logistic regression, neural networks, support vector machines, clustering, dimensionality reduction and principal component analysis, anomaly detection, and recommender systems. As with every other Stanford course I've taken, Prof. Ng precedes each segment with a motivating discussion and examples. Graded portions of the course include a quiz after every topic and a programming assignment, in MATLAB/Octave, after most of them.
The programming assignments are excellent. Although 95% of the code comes to you pre-written, what you write really goes to the heart of that week's topics. Given the breadth of the course, these assignments nicely provide depth and meaningful rigor. The quizzes are very fair and sometimes nicely open your eyes to subtleties of the topic you may not have appreciated.
Machine Learning has migrated along with all Coursera courses to their new platform, which offers the benefit of "on demand" scheduling flexibility (you can start whenever you want) but has some unfortunate downsides. Chief among these is the fact that the quizzes provide no feedback (as they used to) and can be taken as many times as you want. With enough persistence, anyone can score 100% in the course. These are minor deficiencies, however, and don't detract from this course's well-deserved reputation.
Those who take and enjoy Machine Learning should consider following it up with The Analytics Edge, an MIT course offered through edX. The Analytics Edge is more about applying data analytics, including but not limited to machine learning techniques, to a wide variety of real-world problems. It's a great complement to this course, leading you through the many ways data can be parsed and processed to illuminate, predict and explain.

Eat your peas! That's the message of this introduction to good programming practice and hygiene, which includes writing specifications, avoiding bugs, designing and running test suites, and creating abstract data types. The course focuses on the Java programming language, which formalizes and exposes these elements to the programmer to a much greater degree than, say, Python. So while this course will teach you Java if you're new to it, think of it as a course in programming principles rather than programming. That means the coding assignments focus on anticipating edge cases and what can go wrong rather than cool functionality, but again, it's about eating your peas. The course materials include 12 "readings" or textbook-like chapters, three programming assignments, and a final exam. Each reading is broken into segments with exercises between them. The final exam draws heavily from these exercises and is not difficult. You'll notice I haven't said anything about lectures. There are video lectures, but in these, Prof. Miller essentially reads the readings -- and since the readings are quite well-written, I suspect not too many students watch the lectures. That's too bad -- the course can sometimes feel more like a great self-study resource than a class, but there's no question that the material is both important and well-presented. Some of the topics dip generously into computer-science theory, but with the practical goal of avoiding traps and achieving efficient coding. 6.005.1 covers the first half of the one-semester residential 6.005 course, spreading it over 12 weeks -- much more time than is necessary, so you'll likely find yourself idle now and then. Overall, another great Course 6 offering from MIT.

This course is geared toward those with some experience in R who want to progress further, and with particular attention to data-science applications (R is especially well-suited for these). It was produced by Microsoft in partnership with the Technical University of Denmark and is taught by Prof. Anders Stockmarr. He is a great instructor, and the lessons are well-organized and clearly presented. About 2/3 of the lectures treat basic "nuts and bolts" topics in R but quickly progress to more advanced operations relevant to statistics and data analysis. The final third of the course tackles more specialized data science topics -- data manipulation, simulation, linear modeling, and graphics. Tutorial exercises, with answers provided, interleave the lecture segments (often following a righteous suggestion to get some coffee); then, for each unit, there's a quiz and a "lab" that involves actual programming. What is ingenious about the presentation is how, as you learn the topic at hand, you're also nudged along to improve your proficiency with other commands and R capabilities -- but without getting lost or frustrated. As a result, your overall comfort level with R increases substantially over a sequence of relatively short units. The examples are interesting and fun, and the overall workload is not excessive (I completed the course over 8 days).

"So without further ado," Prof. Katsaggelos likes to say at the beginning of a lecture, "let us proceed with this exciting material." He's smiling at the end of that sentence -- as if just maybe "exciting" is a little strong. It is without question interesting and well-presented, however. This course is a comprehensive overview of virtually every important topic in digital image processing. The course begins with a whirlwind review of signals and systems in the digital domain, and moves on to cover motion estimation, image enhancement and recovery, image and video compression, segmentation, and the fascinating (maybe even exciting) topic of sparsity, which has applications far beyond image processing. There are 12 weeks of study, each week consisting of about 2 hours of lecture and a quiz, which includes one or more homework problems implemented in Matlab. For those unfamiliar with Matlab, fear not, a book chapter is provided and it has everything you need. Prof. Katsaggelos is a fabulous teacher. He speaks clearly and engagingly, the lectures are well-organized, and although this is a matter of personal taste, I think he has a wonderful speaking voice. There is no textbook, but downloads of the lecture slides (which are comprehensive) are provided. A word of warning: although billed as a "fundamentals" course, it presumes familiarity with basic principles of digital signal processing and some fairly advanced linear algebra. If circular convolution, Bayesian probabilities, singular value decomposition and linear inverse problems don't ring a bell, then most of the lecture content will sail gorgeously over your head like poetry in a foreign language. HOWEVER, do not shy away from the course for that reason! The quizzes test you at a pretty high level, and even if the math is unfamiliar, you'll still learn a lot about image processing. Prof. Katsaggelos describes the key concepts nicely and provides many visual examples that make those concepts accessible. I would offer two minor caveats. First, while the Matlab problems were worthwhile, they're entirely analytical; I wish there had been more opportunity to play with some of the many free image-processing tools out there that let you apply filters and adjustments using slide bars and the like. Second, the course is entirely unstaffed. If you have a question, you'll have to find the answer on your own or hope for an assist from a fellow student. I should also mention that the new (as of June 2016) Coursera platform is a big step down from the old one for reasons too numerous to complain about here. All that said, this is a great course -- a thorough treatment of a very interesting set of topics.

No lyrical odes to the wonders of flight open this rigorous introduction to
aerodynamics. Instead it’s an abrupt nosedive into the character-building
equations. And they keep on coming. Which shouldn’t surprise anyone, because
aerodynamics is mostly fluid mechanics and fluid mechanics is bone-breaking
math. The course initially tips its hat to aspects of aircraft performance
such as vehicle range and cruise analysis, but most of the time is spent on
the more fundamental topics of thermodynamics, flow equations, aerodynamic
modeling, shock waves, and boundary layers. The course uses a “flipped
classroom” model that dispenses with traditional lectures, instead devoting
video instruction time to solving problems. The absence of an organizing
lecture sequence may seem dismaying at first, but in fact, the approach works
quite well. The written materials are clear and complete, if terse, and the
highly mathematical subject matter really takes on life only in the context of
problems anyway. For those looking for elaboration, the standard Anderson
textbook is a useful reference. Each course module includes a series of
embedded problems that sharpen comprehension of the written material (with
accompanying explanatory videos after you’ve tried them); “sample problems”
that are solved in videos and are less “samples” than a key part of the
instruction; and several often-challenging “homework” problems that push your
understanding to a higher level, and really function more like quizzes. The
dedication of the staff, in particular Prof. Darmofal himself, to this course
cannot be overstated, nor can its contribution to students’ success. The
material is cumulative, so that if you fall overboard early, you’ll drown in
the equations – and the staff’s energetic responses to student queries tossed
many of us a needed life preserver. When you’ve finished, and can take a wider
look at what you’ve learned, you’ll be amazed at the size of your toolbox –
how much you can predict about the aerodynamic performance of a wing based on
the slimmest description, the range of conditions you can model, the way once-
mysterious fluids concepts have become second-nature. If you’re looking for a
thorough introduction to the mechanisms (if not the wonders) of flight,
sharpen up your math skills – fluency in vector calculus, differential
equations and Fourier operations is a must – and get ready for a rough but
rewarding ride.

This foundational course in mechanical engineering explores various
indignities (stretching, squeezing, twisting, and bending) to which mechanical
structures can be subjected, and their behavior in response. While
introductory, the course is not easy (it’s MIT, folks!), but is exceptionally
well taught. The first four weeks focus on axial loading (the stretching and
squeezing) of bars and trusses. Next you move on to torsion and then bending.
Each new unit builds on the previous one, and you see how the new concepts are
elaborations of what you’ve previously learned. It all comes together in a
final unit on elasticity, and there are two optional units that delve further
into material stress concepts. What’s covered in class is analytical, but
you’ll also begin studying the finite-element (FE) approach to solving
structural problems and learn about the computational “solver” tools that
engineers use every day. The FE segments neatly parallel the graded class
work, with problems you’ve solved analytically now represented visually in an
Akselos window. It’s a blast to see what happens to the structure – how the
color-coded stresses change and the structure deforms – as you vary the
applied forces and structural properties. These segments also provide a
glimpse into the world beyond 2.01, where various simplifying assumptions
don’t apply. The instruction is unparalleled. Simona Socrate is articulate,
engaging, funny, and teaches with chalk-breaking passion. Yes, the class is
taught on blackboards (many, actually), but you needn’t take notes – Prof.
Socrate has already taken them for you, in color. She knows where you’re
likely to get confused and patiently walks you through the minefields. In her
opening video, she promises that the class will be a partnership, that she’ll
be there for you – and she means it. The staff does a wonderful job keeping up
with questions on the discussion board, but the most energetic poster is Prof.
Socrate herself. She answers questions. She responds to concerns. She is known
to quote Dante. There are 9 weekly problem sets, your best 7 of which account
for 30% of the grade. A midterm quiz counts for another 30%, and the final
quiz is worth 40%. All of the graded assignments are very fair – even when
challenging, none of the problems go beyond what’s been taught. There are also
weekly “recitations” in which a staff member solves example problems from
start to finish, and Prof. Socrate sometimes posts videos solving some of the
more difficult homework or quiz-prep problems. But in all cases, extensive
(and extremely well-written) solutions are provided. These deserve close study
– collectively, they would make a great textbook. Anyone with even a passing
interest in engineering (and a decent background in basic calculus) should
take this introduction to how the built world works. Look around you: every
structure you see is still standing because the behaviors and vulnerabilities explored in
this course have been successfully anticipated. Beams and bones, bridges and
nachos -- the concepts you learn in 2.01x are relevant to all of them.

The Analytics Edge (TAE) provides a solid, engaging introduction to the techniques of "big" data analysis and machine learning -- and much more. The "much more" is how it extends the nuts and bolts of data analytics into higher-level questions of strategy, i.e., using tools not only to answer questions, but to gain an edge. The course is built around the clunky but powerful R language and, at the end, the use of spreadsheet functions to perform optimizations. Topics covered include linear and logistic regression, classification and regression trees and forests, clustering, text analytics (word clouds!), clustering, data visualization, and linear and integer optimization. Each unit consists of three lecture sequences that teach implementation of a specific technique in the context of two or three illustrative, and very interesting, problems; and a homework assignment where you apply what you've learned to a new problem. The problems are engaging and well chosen -- the real deal, applications of data analytics you've heard of and surely wondered about: Moneyball, spam filtering, healthcare outcomes and spending decisions, how businesses such as airlines segment customers to understand their markets. If this were not enough, it's only the foundation. Where the course really shines is in taking the analysis to the next level and addressing questions of strategy. Say you're a parole board member trying to predict whether a violator is likely to commit a new crime. You use various techniques to finesse a model, yet find that its predictive accuracy is no better than a baseline guess. But wait! Although the overall accuracy may be no better, your model may be tuned to virtually eliminate false negatives -- prisoners you may have thought, wrongly, were safe to release, but weren't, at the expense of false positives (prisoners you could have released, but didn't). If the strategic concern is public safety, overall model accuracy is far less important than its performance along the key strategic metric. Graded course assignments include "quick questions" that accompany the lectures, a pair of problem sets for each unit, a comprehensive final exam, and a Kaggle competition that pits you against your classmates in making predictions from a data set using all you have learned during the first half of the course. Although this is, overall, a fabulous course, there are a few negatives. The problem sets, while interesting, progressive and well thought out, can be tedious -- a lot of the tasks are trivial and repetitive, and it's not always clear what lesson the authors are driving at. And while the community TAs were dedicated (and often heroic) in fielding questions and offering help, the actual course staff was mostly absent -- a sadly common occurrence once a MOOC has had a few successful runs. As a consequence, results for the auto-graded Kaggle competition weren't released for two weeks and, when they came out, there was no explanation about how grades were computed, how the problem should have been approached (our independent variable was not well chosen, given the limitations of the data set), or why some students had weirdly high scores (they cheated, it turned out). The general lack of staff communicativeness also led to grumbling about the final exam, with numerous discussion posts questioning this or that problem. Fortunately, these lapses did not meaningfully interfere with an excellent learning experience, and can readily be corrected.

I took this course in 2015, when all three of the wide-ranging topics were included in a single session. The focus throughout is on theoretical underpinnings and key devices that have emerged from them. The three segments together represent an online version of the residential 3.15 course and were prepared for MIT students. Prof. Ross has generously made them available through edX, but she did not participate in the edX course itself. Instead, course manager Jessica Sandland, a great teacher in her own right, did an excellent job administering homework assignments and exams, answering our questions, and keeping everything on track. Prof. Ross begins with a thorough foundational introduction, and then moves on to applications and devices. This installment of 3.15, which covers semiconductors, is by far the most rigorous of the three and includes an introduction to diodes, transistors, and photovoltaics. Do not get discouraged! Some of the homework assignments and exam questions come as quite a challenge given the easily followed lectures. For me, a textbook was essential. Fortunately, Prof. Chenming Hu has written perhaps the best one out there and offers it free online. Download and read it. When you finish this course, you will *really* understand semiconductors at a deep working level, from quantum states to band structures to electrical behavior. And know that the next two installments of the course are easier.

This fifth installment of the UCSD bioinformatics series is surprisingly short -- only two weeks of material, less than half that of most other installments. The biological topic is how we infer which genes orchestrate various processes in a cell. It continues concepts first introduced in part III -- gene duplications and genome rearrangements. Here the primary focus is on clustering techniques to identify genes likely to be expressed and regulated together and, therefore, collectively responsible for a particular biological phenomenon. These techniques, including k-means clustering, the E-M algorithm, and hierarchical and distance-based clustering, are interesting and lend themselves to straightforward coding. There's a fair bit of material covered in two weeks, but still, it's only two weeks, and in my session you had six weeks to complete the assignments. Depending on how the courses are scheduled, this one can readily be taken in tandem with one of the others.

This is, by far, the most difficult segment I've encountered in this course series (having taken parts I through V). It addresses two fascinating high-level questions in biology: how do we know what evolved from what, and why does T. rex look so much like a chicken? That first question has very practical implications in identifying the animal source of viruses such as the SARS pathogen, but answering it requires a deep dive into the challenging topics of phylogenies and evolutionary trees. Here the hacker track offers up some pretty serious ruts and bumps, with problems that may have you forgetting about the biological dimension altogether as you ponder leaves and limbs and other rarefied artifacts of graph theory that can be pretty tough to turn into working code. Then it's a sudden turn into the world of computational proteomics, which re-introduces mass spectrometry (originally covered in part I) but with newer and hairier twists. Once again the broader biological questions dissolve somewhat in the technical details of analyzing spectra (and more graph theory), but spectrometry is itself such a basic analytical tool for quantitative biologists that you never feel too far removed from the science. Overall, this course segment is tough, but also rewarding once you bend all that graph theory to your will -- and forewarned is forearmed.

This course begins a six-part series on bioinformatics algorithms that works its way through the excellent textbook written by Professors Pevzner and Compeau. In this first installment, you explore what most people probably think of as bioinformatics: sleuthing through DNA to find patterns and "hidden messages" -- that is, functional areas that direct gene expression or otherwise affect what DNA does and how it does it. How you find such regions without knowing in advance what you're looking for is what this class is all about, and it involves algorithmic and statistical analysis. If you've taken a course on algorithm design (the Stanford MOOC is fabulous), here's where you get to apply those techniques to the life-science domain. The course offers two tracks: a "biologist" track for the computer tenderfoot and a "hacker" track for more experienced programmers. Although it's certainly possible to get a lot out of this course without programming, the heart and soul of bioinformatics is training your computer to do amazing things with biological data. The course is exceptionally well organized and well staffed. Each week's unit has a series of lessons presented in an interactive version of the professors' eminently readable and often entertaining textbook. The lessons contain programming tasks that implement various concepts introduced in the text, as well as a quiz that nicely tests your knowledge at a higher level. Some of those programming tasks are pretty challenging. Those on the biologist track undertake an extensive series of non-programming exercises instead. There are also short lectures which, while useful and entertaining, aren't actually necessary for success; the interactive text is so understandable and complete that it has all you really need. This course has enjoyed well-deserved acclaim and is the definitive MOOC for those interested in bioinformatics.

The plot thickens in this second of three modules that constitute the online version of MIT 6.004, Computation Structures. In part 1, we descended deep into the gate-level workings of digital circuits. In this installment we jump up a level to programmable architectures: the datapaths and control units that process assembly-level instructions into outputs. This is where you really begin to learn the design and operation of modern processors. Organized around a hypothetical, simulated processor called the Beta, the labs have you coding sorting algorithms in assembler and actually building, on the screen, a working implementation of the Beta from hardware components (which you previously built from transistors on up during the first course module). Building the Beta is a worthy and rewarding challenge requiring attention to detail, careful choices, and some creativity. The presentation, problem sets and labs in 6.004.2x are flawless -- often dazzling to us nerdy types. The lectures are never boring and always understandable, with interesting digressions into the limits of computation, the design of compilers, and the building blocks of computer memory. In addition to instruction sets and basic processor architecture, this module covers stack operation and cache design. Once again, it's about four weeks of material from the residential class spread over 12 weeks of study. This can be awkward in terms of continuity -- re-learning complex topics studied months before in preparation for the final exam can feel like prying the lid of an old paint can -- but if the relaxed schedule means more people with busy schedules can participate, it's a price well worth paying.

Excellent introduction or refresher, taught by a first-rate professor. The
focus of the course is introductory statics. Lectures were well-delivered and
entirely self-contained so that no textbook was necessary, although some
problems were drawn (with attribution) from the McGill & King textbook on
Statics (which I recommend). Professor Whiteman took pains to connect each
week's subject matter to real-world problems, and the weekly quizzes provided
a good opportunity to really think through the material.

This wide-ranging, briskly taught introduction to computer networks is now offered as a self-paced course, which for many will come as a big relief: when offered in 2014 over eight weeks, the workload must have been brutal. The course consists of eight units, which cover the Internet and its various service layers, networking nuts and bolts such as packet switching and congestion control, security, and network applications. There's a quiz after each segment of each unit, for a total of 74(!) of them, as well as midterm and final exams. The teaching is excellent, but some topics are just skimmed in the survey-style presentation, and the quizzes and exams often go beyond or outside of what was taught. A textbook or readiness to surf the Internet for resources is well-advised. One unfortunate omission from this version of the course is the famously challenging "Simple Router" lab, which has students writing C code for analyzing packets and forwarding them. Having worked this lab on my own, I can attest to its value as an adjunct to the often painstakingly detailed dissections of packet structure and header contents; this arcane subject matter, while rather dry on its own, takes on life when you actually pull packets apart, put them back together and send them on their merry way. The good news, however, is that the instructors plan to release an entire lab-oriented networking MOOC in the near future, which devotees of this course eagerly await.

This is a polished, professionally produced introduction to the Java programming language. It's suitable for a wide audience, ranging from those with no programming experience at all to people like me looking to fill a hole in our repertoires. The course is organized progressively, beginning with Java basics and covering gradually more advanced topics. Each unit includes a series of short lectures, most of which are followed by brief programming problems or questions. A problem set, with more in-depth programming assignments, follows most of the lecture series. There's also an optional final project. The instructors are excellent and no textbook is necessary (although beginners may find themselves occasionally in need of a reference -- and there are plenty to be found on the web). The course expects you to install the free BlueJ programming environment, and provides you with downloadable files corresponding to the online programming assignments. This approach not only provides greater opportunity for debugging and program refinement than is possible in a screen submission, but also familiarizes you with a very useful programming tool. For those who care about credentials, note that Udacity no longer offers certificates of completion for those who have not enrolled in the expensive pay version of the course; this class is so introductory, however, that few will suffer as a result.

This wide-ranging introduction to the mechanical behavior of materials covers
a lot of ground: stress/strain behavior at the bulk and atomic levels,
principal stresses and transformations, beam bending, column buckling, the
behavior of cellular and crystalline materials, creep and stress relaxation,
brittle fracture, and fatigue. Prof. Gibson covers these varied topics at a
brisk clip but at sufficient depth to provide a working knowledge of each
subject. She frequently provides examples from the natural world, showing how
animals and plants have developed sophisticated physical structures to resist
or tolerate mechanical injury – for example, how woodpeckers avoid brain
damage.
There are 12 weekly problem sets and three noncumulative exams, each covering
one-third of the course material. All of the exam problems are very reasonable and
follow directly from the lectures and weekly example problems that Prof.
Gibson solves for you. No textbook is necessary (although I found David
Roylance's book, Mechanics of Materials, to be an excellent supplement -- it
nicely covers all of the syllabus topics). The lectures themselves are clear
and well-organized, having been recorded from the live class at MIT. My sole
criticism relates to the amount of time spent writing on the blackboards – not
just equations and graphs, but whole sentences and explanations. These might
be better written out in advance or simply distributed beforehand, with the
freed-up lecture time devoted to further elaboration of the very interesting
topics.

This was the best chemistry course I’ve ever taken, and I majored in
chemistry. One reason is that, although there are plenty of reactions and
kinetics, the course is really an exploration of how chemistry serves the
process of discovering, optimizing, and ultimately marketing drugs. So
Professor Stevens first takes you through the basic business and regulatory
framework of the pharmaceutical industry – clinical trials, the FDA, how drugs
are protected by intellectual property. The course then covers the basics of
pharmacokinetics: what drugs actually do, how the body absorbs, distributes,
metabolizes and ultimately eliminates them – and how drug designers use dosing
regimens and molecular design to obtain efficacy without harming the patient.
From there you dive more deeply into the chemistry of binding and metabolism,
and then into the mechanics of drug discovery – the use of automation,
combinatorial chemistry and targeting strategies to find needles in the vast
haystack of potential molecules that constitutes “drug space.” One aspect of
this course that makes it so enjoyable is the way case studies and anecdotes
are used to illustrate key class topics. The need for regulation is
exemplified by discussion of mass poisonings that have occurred as a result of
drug contamination, for example, and to learn how drug candidates are
identified and optimized, we follow the trail of Abbott researchers as they
develop stromelysin inhibitors to treat arthritis and cancer. The chemistry
topics often involve familiar pharmaceutical names – Viagra, Ibuprofen, and
Tamiflu all make appearances, adding a level of relevance often missing from
courses that dig into the hard science. Professor Stevens is a marvelous
teacher. His superb command of the material is no surprise, but he knows
exactly where his students may get confused and how to pre-empt that
confusion. He is quick with clever, illuminating analogies and visual
illustrations, and the lectures are always engaging, never boring. Also, his
level of dedication to this course, actively monitoring the discussion board
and answering questions personally, was truly heroic. If you have a decent
chemistry background and even a passing interest in the world of pharma, you
will love this class.

This innovative, challenging and rewarding course approaches a traditional
linear-algebra curriculum from a computational perspective. Students write
procedures implementing key mathematical concepts, and apply these to
interesting labs that have you changing the perspective of a photograph,
dabbling in machine learning, and writing a simple search engine. The lectures
are well-organized and the written materials are superb. Note, however, that
this is not primarily a programming course -- the point of the programming is
to understand and apply the math; those looking for a Python introduction as
such might prefer other options. In fact, because solutions to the programming
assignments are not provided and code cannot be shared or posted, your coding
skills may not improve much. And if you’re new to Python, expect to turn
frequently to external tutorials and resources. Those with no prior exposure
to linear algebra may also find themselves playing catch-up given the fast
pace and abstract focus of the lectures. The course emphasizes proofs at the
expense of explained examples and illustrative applications – great for math
lovers but maybe not for linear algebra neophytes. Overall, while the
presentation moves at a brisk march and the workload is considerable, those
willing to devote the time will find the pieces fitting together into a unique
learning experience. The course as given was actually only the first 8 weeks
of the12-week course taught at Brown, and a mini-course covering the remaining
material is planned. Future versions will hopefully cover the entire
curriculum in a single session.

MITx has divided the residential course called "Computation Structures" into three parts, and this is the first. It covers digital circuits, beginning with basic information concepts such as encoding schemes, entropy, and signaling. From there you move on to CMOS, combinational logic, sequential logic, and finite-state machines, and finally to the broader topics of performance measures and design tradeoffs. The course is introductory but, as with most MITx courses, often challenging. What would be taught in 4 or 5 weeks at MIT is spread out here into 8 weeks, with 2 units of material released every other week. That pacing is good and bad -- certainly it would be tough to get through all this material in so short a time, but I suspect most students found the hiatus between material releases a bit awkward.
There are lectures, problem sets, graded homework assignments, fabulous labs (more on that below), and midterm and final exams. The lectures, by Chris Terman, are engaging and clear; wry humor runs through the lectures and also the problem sets. Prof. Terman, however, is an off-stage presence. The course is run by Silvina Hanono Wachman, who delivers the tutorials, energetically answers questions on the discussion board, fixes whatever needs fixing, alleviates confusion, and does an amazing job at all of this.
The labs are a highlight. Students build and test digital circuits using an online simulator, culminating in the design (with healthy guidance) and implementation of a 32-bit arithmetic logic unit. Another lab highlight is programming a Turing Machine simulation, which not only hones your skills with finite-state machines but offers a glimpse into the fundamentals of computability.
The final exam was very challenging, with a single chance to answer each question, but also very fair based on the material covered. Overall this is a rigorous, well-organized, often exhilarating and occasionally entertaining introduction to digital logic and design.

"So, Professor Yerraballi, what are we going to learn today?" asks his senior colleague, Professor Valvano, eagerly. Prof. Yerraballi barely finishes describing the concept of interrupts when he is almost interrupted himself. "Yes," says Prof. Valvano, "but you know me. I like to build things. What are we going to build?"
And there you have the heart and soul of this fantastic course, one of the best you will ever take. You build cool projects using a programmable microcontroller and various accessories. You learn how these ubiquitous devices work, how to program them, and how to interface them with other devices. Each of the 16 progressive modules in this largely self-paced course covers a new topic and has you building and programming a new project. The modules start with first principles (fundamentals of computers and electronics, C programming) and move on to more specific but widely relevant concepts: serial interfaces, interrupts, finite state machines, digital-to-analog and analog-to-digital conversion, game design, and the Internet of Things. You build things like traffic lights and musical instruments and games.
Beyond the graded labs, Profs Valvano and Yerraballi demonstrate more ambitious projects (such as cars and robots) that can be made using the principles you've just learned, and they provide links to supporting resources for motivated students. In fact, Prof. Valvano's website brims with a vast library of projects and additional materials. He has authored a number of hands-on books on embedded systems that are well-regarded and serve as excellent references for this course.
What is truly unique about this class is how the specific learning topics are always grounded in more fundamental concepts, and how they also serve as platforms for broader themes that are emphasized throughout the course:
• Design and development processes: how engineers actually plan and execute projects.
• C programming: the overview is so comprehensive that, although the class presumes prior knowledge of C, the ambitious student lacking such knowledge could develop proficiency based solely on the course lectures and materials.
• Requirements documents and the business side of engineering.
• Engineering best practices.
The quality of the teaching is superb. The two professors obviously like each other and present very effectively. There are helpful animations and supporting written materials. An excellent project simulator and debugger helps you get the code right before you implement it on the real board. And an onboard logic analyzer and oscilloscope lets you test what you've built and diagnose the errors.
In their closing remarks, the two instructors offer some advice for budding engineers. "Be courageous," says Prof. Yerraballi. "Be humble," says Prof. Valvano. They say more than this, of course, but you get the idea. This is a unique introduction to embedded systems, but that's really only the beginning.

This wide-ranging introduction to Linux is well-suited to beginners who, like
me, have almost no knowledge whatsoever of Linux. The course is organized
into 18 self-paced topical modules, each consisting of several subtopic
sequences. The subtopic sequences, in turn, each contain a series of
instructional web pages with text and graphical content, short (each less than
2 minutes) video segments illustrating use of a tool or command discussed in
the web pages, a few review questions, and a "lab" that has you perform tasks
on your Linux system. The review questions and labs do not count toward your
grade, which is based solely on a 30-question final.
Although the labs sometimes require some real thought, overall the course is
not difficult. With content almost exclusively presented on static web pages,
the experience is more like reading a well-written, well-illustrated book with
chapter-ending exercises available on the web. I had no problem finishing it
up in two weeks. The course emphasizes breadth rather than depth, which is
exactly right, in my view, for an introductory treatment. After getting
comfortable with the basic features of Linux, and then taking a grand tour
through the most common commands and capabilities, you'll feel that you've
built a pretty solid foundation for more advanced (that is to say, "advanced
beginner") work. There are tons of helpful Linux tutorials on the web, and
this course provides the basic grounding to make those tutorials meaningful.
The course materials take worthy pains to separately treat the three most
common Linux distributions, both in terms of helping you install and navigate
your Linux package and for later course topics where the details diverge among
distributions. Because of the modular organization of the course, it's easy
to skip the distribution-specific segments that don't relate to your version.
Neophytes who take this course with the right expectations will find it very
useful and easily digested. People who already have basic Linux training may
also find it useful on a topical level, but should be prepared to skip through
a lot of what they already know.

Surely there is no better venue for a course about Thomas Jefferson than the
campus of the University of Virginia, which he founded late in his life. This
compact class consists of seven units that each include lecture segments
totaling about an hour, readings, and a tour of places and institutions
central to Jefferson’s life or its study today. These tours are no mere
travelogue – Jefferson’s life and philosophy are so intimately associated with
his Monticello estate and the “academical village” he designed for U.Va. that
to experience them, in well-produced videos with insightful commentary,
connects you to the man even as reading his letters and other writings
connects you to his mind.
Professor Onuf is a wonderful teacher. His lectures are absorbing and well-
delivered, often passionately so. The most compelling feature of this course
is his focus on Jefferson’s ideas rather than dates and events. Prof. Onuf
covers Jefferson’s vision of America’s revolutionary promise and later
Americans’ evolving views of Jefferson; the political philosophy that informed
Jefferson’s draft of the Declaration of Independence; his heterodox views on
education (primary purpose: to sustain the American experiment) and religion
(deeply suspicious of organized “priestcraft”); and Prof. Onuf does not shy
away from Jefferson’s provocative views on race and slavery. The readings,
usually Jefferson’s own words in letters and public documents, nicely
complement the lectures; they are short and very well chosen.
Students who take this class will acquire, in a short time, an understanding
of Jefferson – the man and the mind – that has real staying power. Everyday
encounters with politics, education and even architecture will have you
contemplating Prof. Onuf’s rhetorical question: “Is it Jeffersonian?” This
brief, enjoyable immersion into the essential Jefferson packs an outsize
pedagogical punch.

Part I of Stanford’s course on algorithms, taught by Prof. Tim Roughgarden,
begins by laying out the criteria by which an algorithm can be judged -- its
complexity in time and space, and how well it scales to large input sets. The
class then turns to divide-and-conquer algorithms, graph algorithms, and data
structures such as heaps, binary search trees, hash tables and Bloom filters.
The class is not introductory -- programming ability and basic familiarity
with the concepts presented is assumed. As it happens, all of the topics in
this class (and its successor) are covered at a simpler level in the excellent
MIT 6.00x online class, which should be considered a prerequisite for this
one. I would have been quite lost without that introduction, and certainly
never felt as if I was covering the same ground again -- this class delves far
deeper.
Prof. Roughgarden is a fabulous teacher. His presentation is so articulate
and so engagingly down-to-earth that you can lose sight of how complex the
material actually is. Fear not, however, because the challenging weekly
problem sets will have you scurrying back to the slides and maybe the lectures
as well to deepen your understanding. The final exam has a few difficult
problems but by and large is easier than the problem sets.
Besides the problems, there are weekly programming assignments that have you
coding up one of the algorithms discussed that week. You can use whatever
language you want -- you’re given a dataset and asked to submit results. In a
couple of cases, the datasets are so large that your programming environment
may crash, as mine did, resulting in panicked discussion-board postings a lot
of ad hoc advice. It was unnecessary. Yes, coding algorithms in the real
world means figuring out how to accommodate the limits of your system, but
such strategies are not covered in this course and solutions can be elusive.
Just getting the algorithm to work right is challenge enough.
This is a computer-science course and there’s plenty of math – proofs galore,
probabilities, topologies and much more. But it’s never math for math’s sake.
Prof. Roughgarden always introduces topics with a statement of motivation –
how a mathematical construct can describe or model real-world systems, the
sometimes-surprisingly practical applications of abstract graph algorithms or
esoteric data structures. The syllabus progresses through a diverse series of
topics but the unifying theme is identifying a job to be done and figuring out
how best to do it – and more importantly, understanding the elastic limits of
“best.”

This class picks up where 6.00.01x leaves off, applying the programming skills
you've learned to some important topics in data science -- simulations,
probability and the use (and misuse) of statistics, the interpretation of
experimental data, graph problems, optimization, and machine learning. As in
6.00.01x, the lectures are first-rate and the textbook is not only the best
computer-science primer I've ever read, but the best I can imagine -- it's
readable and clear, and frequently witty. I've found it to be an excellent
reference and refer to it often. Although the topics in 6.00.02x concern "data
science and computational thinking," the heart of the problem sets is still
programming; so if you're afraid you've left the challenging world of classes,
inheritance and recursion behind last semester, you can rest easy -- they're
back.

This wonderful introduction to the dynamics of mechanical systems – rolling
wheels, swinging arms, spinning amusement-park rides – picks up where standard
physics intro courses leave off, and introduces an engineering approach to the
analysis of physical systems. Unfortunately it’s only the first half (six
weeks) of the live class taught at MIT, but it covers the key foundational
topics in dynamics: kinematics, equations of motion, velocity and acceleration
in 2D and 3D frames, moments of inertia, and imbalance behavior. Prof. Gossard
is an excellent teacher and brings a welcome human touch to a subject where
students can easily get lost. He knows exactly when you’re likely to get
confused and how to pre-empt it. He’s also articulate, funny, and warm. When
he says he chose a carousel problem because he likes going to carnivals, you
want to go to one with him. The course consists of a series of video lectures,
graded problem sets and two exams. The lectures were filmed during the live
class, which Prof. Gossard teaches using chalk and a series of busily moving
blackboards; there are no slides. To take effective notes, therefore, you’ll
need either a quick pencil or skill with the Windows snipping tool. Prof.
Gossard frequently engages students , and without the social context of a live
class, these interactions can sometimes drag a bit (particularly since the
students’ responses are generally inaudible). There are consolations, however:
the camera often alights and lingers on the classroom hotties, surely by
inadvertence, as well as the occasional hippopotamus-like yawn. Prof. Gossard
and the staff (particularly the tireless Christina Jaworsky) were supremely
dedicated to this course and students’ success in it. They deftly managed some
video challenges, Matlab malfunctions and problem-set glitches. Prof. Gossard
added “office hours” videos that addressed or reinforced topics that had
prompted questions on the discussion board. All in all, a short but well-
focused, well-run and well-taught introduction to some fundamental concepts in
mechanical engineering.

This broad, fast-paced survey of AI paradigms and strategies is the first entry in Columbia's AI MicroMasters series. It covers "the usual suspects" such as neural networks and other machine-learning techniques, natural-language processing and intelligent agents, but also includes a variety of state-space search techniques, constraint-satisfaction problems, a challenging introduction to propositional logic, reinforcement learning and Markov processes. It's a grad-level course, and although no special prerequisites are necessary and the concepts are readily grasped by anyone with a decent math background, the number of topics covered makes for a busy schedule. The programming assignments are interesting and rewarding but also require significant effort -- they require putting concepts that are covered in lectures at a fairly high level into practical, working use. I enjoyed the lectures. Prof. Ansaf Salleb-Aouissi is engaging, clear, and delivers her lectures with a cheerfulness that makes them feel personal.
As I note in my review of the second AI MicroMasters course, Machine Learning, this course is very much prerequisite for that one unless you've already had significant prior training in the area. There is considerable topic overlap although almost no subject-matter overlap between the two courses, by which I mean that for most topics covered in great depth in Machine Learning, this course provides an essential intro.

No lyrical odes to the wonders of flight open this rigorous introduction to aerodynamics. Instead it’s an abrupt osedive into the character-building equations. And they keep on coming. Which shouldn’t surprise anyone, because aerodynamics is mostly fluid mechanics and fluid mechanics is bone-breaking math. The course initially tips its hat to aspects of aircraft performance such as vehicle range and cruise analysis, but most of the time is spent on
the more fundamental topics of thermodynamics, flow equations, aerodynamic modeling, shock waves, and boundary layers. The course uses a “flipped classroom” model that dispenses with traditional lectures, instead devoting video instruction time to solving problems. The absence of an organizing lecture sequence may seem dismaying at first, but in fact, the approach works
quite well. The written materials are clear and complete, if terse, and the highly mathematical subject matter really takes on life only in the context of problems anyway. For those looking for elaboration, the standard Anderson
textbook is a useful reference. Each course module includes a series of embedded problems that sharpen comprehension of the written material (with accompanying explanatory videos after you’ve tried them); “sample problems” that are solved in videos and are less “samples” than a key part of the instruction; and several often-challenging “homework” problems that push your
understanding to a higher level, and really function more like quizzes. The dedication of the staff, in particular Prof. Darmofal himself, to this course cannot be overstated, nor can its contribution to students’ success. The material is cumulative, so that if you fall overboard early, you’ll drown in
the equations – and the staff’s energetic responses to student queries tossed many of us a needed life preserver. When you’ve finished, and can take a wider look at what you’ve learned, you’ll be amazed at the size of your toolbox – how much you can predict about the aerodynamic performance of a wing based on the slimmest description, the range of conditions you can model, the way once-
mysterious fluids concepts have become second-nature. If you’re looking for a thorough introduction to the mechanisms (if not the wonders) of flight, sharpen up your math skills – fluency in vector calculus, differential
equations and Fourier operations is a must – and get ready for a rough but rewarding ride.

This introduction to computational engineering simulation is in many ways 3 courses rolled into one: an introduction to the problem-solving steps engineers use to model physical systems, including the steps before and after the simulation; an overview of finite-element analysis and the finite-volume method, including brief but meaningful summaries of structural and fluid mechanics; and the "hands-on" part, where Prof. Bhaskaran teaches you how to use ANSYS to solve engineering problems. ANSYS is an enormously powerful tool but it's fussy and often non-intuitive; this part of the course gets down into the weeds of menu selections and mouse clicks, like a training class for Excel or Word. But the great thing about this course is how it teaches you not only how to work the tool, but how the tool works. There are 4 core modules covering heat conduction, solid mechanics (a bicycle crank and a rocket nozzle flange), and computational fluid dynamics. Two optional modules have you modeling an airplane wing and a wind turbine blade. Supplementing the instructional videos in the flange segment are interesting comments and perspectives from a mechanical engineer who uses ANSYS to design rockets.
Bottom line is that this course is a heck of a lot of fun -- the colorful pictures and animations that ANSYS generates, and the ability to manipulate them in 3D, provide a hands-on understanding that is unsurpassed. (You can see that the bike crank is safe because under load, the blue and red stresses penetrate only slightly into the thickness of the bar.) And I found the compact overviews of solid mechanics and fluid dynamics to be well-delivered and surprisingly comprehensive for the problems at hand. (Finally I really understand the concept of a boundary layer.) The in-lecture questions and homework assignments require understanding of the concepts and facility with the ANSYS tool, but are not difficult.
Obviously this course is ideally suited to engineers in training or those who haven't used FEA or CFD, but anyone who likes playing with cool tools that plumb the physics of mechanical and fluid systems and turn their behavior into dazzling images will have a blast.

Advanced Transport Phenomena picks up where the introductory course, The Basics of Transport Phenomena, leaves off, covering additional topics that are also treated in the optional (but excellent and reasonably priced) textbook -- van den Akker & Mudde, "Transport Phenomena - The Art of Balancing." This course covers convection, radiation, laminar flow, and fluid momentum. What that means practically is that you'll study reactors, friction in pipes and Couette flow through channels, non-Newtonian fluids like mustard and whipped cream, humidity and the wet-bulb temperature, and viscosity. Like the first course, this one features problems that cover the material but are interesting in their own right -- computing the temperature of the Earth, modeling why deserts get so cold at night, making chocolate sprinkles, the aforementioned whipped cream, and painful intestinal gas(!).
But this is not a mere extension of the intro course into additional topics. It is very tough -- note that word "advanced" in the title. Throughout this class you'll use "microbalances" over small system regions to generate a profile of how things change over space and time, and it can be quite challenging to figure out what quantities and regions to model. There are more equations and formulas than last time around, and again, the challenge is not so much in their number as how to choose and combine them. Figuring out how to think about a problem, and then puzzling through unexpected zigs and zags in the mechanics, can sometimes feel like a graduate-level enterprise. And of course you're expected to have fluency with all of the material you learned in the first course.
Don't be put off, though. The lectures and tutorials are excellent, the staff is responsive and dedicated to students' success, and you'll learn quite a lot. The effort is more than repaid by the problem-solving toolkit you'll develop, in only six weeks, across a variety of important chemical engineering topics. Call me old fashioned, but when a man's wife asks him, "Honey, how big a square-profile conduit do we need to change the air in our kitchen three times an hour?" he should be able to respond, without hesitation, "What kind of interior conduit roughness are we talking?"

This final installment of the UCSD bioinformatics series covers two very important classes of tool (algorithms for read mapping, including the Burrows-Wheeler Transform, and hidden Markov models) that address two fascinating questions in computational biology: how do we locate disease-causing DNA mutations and how can we identify the function of a protein from similar proteins despite the cumulative effects of evolution? The six-course UCSD bioinformatics series is now offered under Coursera's new platform, and the courses have been reformatted a bit. The biggest change is that those following the "hacker track" (now called "honors track") and tackling the programming assignments will also have to complete a peer-graded set of "bioinformatics challenge" exercises at the end of the course; in previous sessions, only those following the no-programming "biologist track" were required to complete the challenge exercises. While it adds to the workload, this change is very worthwhile -- it exposes you to databases and tools that computational biologists routinely use in the areas covered by the course. Another change is that the course is now fully self-paced; although you sign up for a particular session, new sessions start every month and your work will carry over through multiple sessions. The idea is to try to place you with a cohort of learners for grading and discussion purposes. One consequence, however, is that course staffing is sporadic; staff may be available to respond to your questions or may not be. The programming problems, particularly the later ones in the course, are pretty challenging, and no online textbook materials are provided for the hidden Markov model unit -- you have to rely solely on the lectures, which for me were sometimes hard to follow. The instructors' excellent textbook is really helpful here. Although I found the course to be a superb learning experience and eventually completed all of the programming and peer-graded exercises, there was no way I could have done so in one six-week session with a full-time job.

This brief introduction to cloud computing concepts focuses primarily on deployment issues -- the costs and benefits of migrating to a cloud and the do's and don'ts of migration. As such, it will be of interest primarily to business managers rather than engineers or IT managers looking for more technical content or consumers interested in the mechanics of cloud operation. The course is organized into 3 segments: an overview with a useful overview of different types of cloud architectures (primarily SaaS, PaaS, and IaaS), a survey of the advantages and disadvantages of these cloud models, and finally, the economics of cloud migration and deployment pitfalls to avoid. There is overlap and some repetition between the second and third parts, and unfortunately a lot of the information, which is certainly worthwhile, is presented in the form of lifeless checklists. In fact, the lectures, while clear and well-articulated, come across like a cloud provider's white paper read out loud. What this course desperately needs is some in-depth studies of use cases to give context to the general principles and guidelines set out in the lectures. There are graded "knowledge checks" that supplement most of the lectures, 3 quizzes (one for each segment), and a final exam. The knowledge checks often frustratingly lack any basis in the lectures to which they supposedly relate, so you wind up guessing among plausible answers. The quizzes largely repeat the knowledge checks and the final exam largely repeats the quizzes, so there isn't much challenge in these. Still, despite the flaws, this course provides a short, useful overview of cloud architectures and deployment issues.

I dropped this course. While the topics in statistics are well chosen and the problems interesting, particularly for those in the life sciences, the course itself had many problems. First, it is completely unstaffed, and I mean completely. This is problematic for any course, but particularly here, where the material was beset by technical problems. For example, a heavily used R function is unavailable in current R implementations, so you have to ignore a good chunk of the code patterns you're given and substitute new code -- not too hard for me, since I've programmed in R, but no fun for the less experienced. The discussion board included complaints about auto-graders rejecting correct answers. Etc. There were no staff responses. In terms of content, I found the lectures to ramble somewhat, and since the content is covered in chapters from the course textbook provided online, I started following that instead. But at least as presented, these chapters are often disjointed -- for example, discussing new topics as if they'd been previously introduced. When I found myself turning to Wikipedia for enlightenment, I decided it was time to bail.

This terrific offering from MIT is unusual in being organized around applications rather than content -- each of the 8 weekly units introduces a different tool used by quantitative biologists, and each week's course topic serves both as a vehicle for hands-on experience with the tool as well as an engaging subject for learning. The tools are Matlab, ImageJ, PyMol, the StarMapping genetics simulator, and the Python and R programming languages as used by biologists; and the topics include population modeling, equilibrium kinetics, molecular modeling, genetics, and disease prediction. These diverse topics are taught by an equally diverse ensemble of instructors, both professors and grad students. In some cases, the instructional videos are drawn from other MIT courses, and there are also "faculty perspective" videos that address larger questions in biology. Half of the graded assignments are "workshops" that give you limited answer attempts, and the other half are "exercises" with unlimited attempts. Those familiar with programming in Matlab and Python will find those assignments pretty easy; newcomers will be challenged. But the progressively organized materials assume no prior background and skeleton code is always provided; you're never just thrown into the deep water. What really makes this course are the varied and interesting topics, with no overall organizing principle or constraint, and the quality of the instruction and materials, which are, as is typical for MIT, first-rate.

This course is now part of Coursera's "Business Strategy Specialization," and its contents appears to have been spread over two of the courses that now make up the specialization. My experience is with the original format,which covered analysis of industry structure, firm capabilities, competitive dynamics, and determining competitive positioning and firm scope. Prof. Lenox is an excellent teacher, and unlike many business courses, this one neither shies away from the underlying microeconomics of business enterprises nor overemphasizes it -- that is, the presentation isn't quantitative but it's solidly grounded in theory. Prof. Lenox is especially good at tying abstract concepts to real cases, and each week's case study further focuses the material on historical business situations. This is truly valuable because concepts such as SWOT and Five Forces analyses can easily become arbitrary exercises in speculation unless you see how they're used in practical decisionmaking. I found the final project particularly worthwhile, and had fun using Coursera as my case study.

Having learned to sequence genes in the last course segment, this installment focuses on how to compare them -- an often-difficult task because a meaningful comparison must consider the possibility of mutations, sharply increasing the complexity of the task. How do you "align" sequences that have unlimited potential for variation? The solution is to be found in "dynamic programming," a powerful technique that is well-presented here. The text and programming assignments are more challenging than those of the earlier course segments, but they are taught clearly and progressively, and the staff is fabulous (I'm talking about you, Giampaolo Eusebi!). Graph theory can be esoteric and abstract, but when anchored to interesting problems in biology, it becomes a lot of fun. The course also covers rearrangements within genes and genomes, leading to ways to compare, say, human and mouse genomes, and more kinds of computational graphs. The questions addressed in this course segment continue to be interesting biologically and now are more challenging computationally. It's all good.

This second installment of the six-part bioinformatics series focuses on sequencing. Gene and protein sequences are the axis around which all of biology turns, and the scale of the Human Genome Project gives a sense of how central a role computational analysis plays. What this course covers is well captured by the "exploding newspaper problem" -- how do you reconstruct the news from a newspaper that's been blown to smithereens? How can you reconstruct a huge DNA molecule from the short segments that can be generated and read? These are problems in graph theory, and this course provides a great introduction to what might otherwise seem esoteric and abstract by grounding theory in the practicalities of biology. As in all courses in this series, there's a "biologist" track and a "hacker" track, and for the latter, the programming assignments can be considerably more challenging than those in Bioinformatics I. But they're fun -- it's very cool to see how graph theory works a kind of magic on problems whose scale makes them seem hopeless. Once again, the interactive textbook is excellent and the lectures, while worthwhile, are not essential. When most people think of bioinformatics, they probably think of gene sequencing, and this course is a great hands-on intro to the topic.

I had the privilege of taking the beta version of this intense three-week introduction to control theory. It's a hands-on experience that covers the basics of control -- i.e., keeping a system operating at a desired setpoint using feedforward and feedback strategies. The course takes a discrete-time approach to avoid differential equations, but the math is still far from trivial, and discrete time is what today's digital controllers use. The first week builds the necessary mathematical foundation of sequences, difference equations and natural frequencies. The second and third weeks get into the meat of control theory, culminating with an exploration of Proportional plus Sum plus Delta (PSD) feedback, the discrete-time equivalent of the well-known Proportional plus Integral plus Derivative (PID) feedback paradigm. Students (reversibly) harvest a propeller arm from an inexpensive drone and combine it with an Arduino controller to create a programmable control system. A series of excellent user interfaces allows you to vary different control parameters and see the effects on the propeller -- does it hold steady, does it oscillate, or does it fly out of control? A terrific simulator ties the math directly to its control effects, allowing you to enter a difference equation and see how well controls an animated helicopter as it changes height. There were no lecture videos in the beta course, but the written materials were so good that I wonder whether lectures are even necessary, and the professors, Jacob White and Joe Steinmeyer, were incredibly dedicated -- fielding innumerable questions, fixing minor glitches, and taking a heroic interest in students' progress and understanding. It's amazing how much we covered in three weeks, though when it was over, many of us were eager for more -- and hopefully, down the road, there will be more.

This course covers the ways in which music can be analyzed, represented, changed, and categorized in digital form. Topics covered include Fourier analysis, sinusoidal decomposition of music, harmonic and stochastic representations, sound transformations, and extraction of audio features from music for purposes of classification and retrieval. The course emphasizes not only programming various signal-processing functions in Python, but also the use of very versatile and just plain cool applications such as Audacity, Sonic Visualizer, a variety of spectral modeling synthesis tools, and Essentia. The programming and most applications require a Linux environment, but the course staff has heroically assembled a downloadable image that can be launched in Virtual Box (which is free), and which has all applications pre-loaded and ready to go. Each week, Prof. Serra presents lectures in three formats: a theoretical overview of the mathematical and physical principles, “demo” lectures that illustrate operation of the various tools and applications, and programming lectures that introduce the code underlying resources you’ll use that week as well as useful background for the programming tasks. The theory lectures are excellent, compressing a lot of technical detail into accessible, understandable nuggets. The demo and programming lectures, which are more free-form, are useful but sometimes ramble a bit. In terms of grading, the first six weeks feature computer-graded programming assignments; weeks 7 through 10 have peer-reviewed assignments that involve analysis and manipulation of music clips. There is also a weekly quiz. And now, some cautionary notes. First, there’s quite a bit of (interesting!) math and, particularly as the course progresses, some real Python programming challenges. Familiarity with the fine points of Python array operations is essential. Second, there were problems related to grading. For code submissions, the auto-graders were very fussy: you thought your function returned true or false, but the grader expected a default boolean and unbeknownst to you, your function returned a NumPy boolean and was marked wrong; or you returned an array in the right format, but unbeknowst to you, the grader expected 64-bit ints and yours were 32 bits. The weekly quizzes varied in difficulty but often had at least one question whose “correct” answer was ambiguous or seemed to contradict the lectures. And while some of the topics such as the discrete and short-time Fourier transforms have obvious and widespread importance, you may be forgiven for asking yourself, when all is said and done, how relevant a lot of what you’ve learned is to the experience, understanding, or organization of music outside some very specialized contexts. Still, learning to unpack a flute solo into its harmonic and breathy components, or to gain insight from spectrograms that at first look like a Jackson Pollack viewed through a screen door, is quite rewarding -- and playing with sounds is just fun. If you’re ready to make the commitment and can tolerate a few frustrations, you’ll get a lot out of this course.

This terrific course, taught by professors at Delft University, covers the basics of heat and mass transfer -- through pipes and membranes, in and out of tanks, falling from the sky and sailing through the air. It's really a solid introduction to the principles underlying chemical engineering. The instruction is uniformly excellent: the professors present a unit of theory followed by problems they solve step-by-step, and then you're on your own for a graded problem set covering that week's material. There's a final exam at the end. Although any course involving differential equations cannot be categorized as easy, the instructors teach from first principles and anticipate areas of likely confusion. The problems they have chosen for the course are engaging and fun -- thermal baths in Iceland, the Three Gorges Dam in China, painting the Eiffel Tower, the formation of acid rain, and ground contamination due to landfill leaching. Each unit begins with an entertaining video illustrating the subject matter in a practical context. (The visit to a waste-treatment plant is not to be missed.) The staff is incredibly friendly, responsive, and dedicated to students' success. Although all necessary materials are provided, students should consider picking up the recommended textbook (van den Akker & Mudde, "Transport Phenomena – The Art of Balancing"), which is unusually well-written and, like the course, emphasizes interesting problems rather than dry abstractions. This course covers about half of what's in the textbook (which obviously goes into greater depth), and a further MOOC, covering more of the material, is slated for release in Fall 2016.

Will four learning modules, one of which is background material, make you a C++ programmer? Nope. But this short course offers a nice introduction, particularly if you already have some exposure to C. The course covers the basics of C++ data types, input/ouput, control statements, and simple classes. Written materials are provided and the lectures, which are very good, emphasize the practical points. Not everything is taught from first principles, though, so if you're new to C-style programming, you may find yourself facing unfamiliar terminology now and then; fortunately, there are plenty of tutorial resources on the web, including ebooks. The assignments could use some improvement: the quizzes are easy and the small amount of actual programming is unfortunately peer-reviewed, which is not well suited to the subject matter. Microsoft should consider providing coding windows that allow you to enter code and have it compiled and executed -- that's the way most programming courses do it, and it would improve the effectiveness of this otherwise worthwhile introduction considerably.

This compact introduction to corporate finance lives up to its name -- in 6 weeks it really does cover the key foundations of the subject. The course begins with the basic topic of risk and return, then moves on to diversification, the cost of capital, project evaluation (starring the all-important concept of net present value), and winds up with an overview of corporate value creation. For such a short course, the mix of basic principles and quantitative analysis is nicely balanced. (The math-averse need not fear anything too fancy.) Prof. Estrada is an excellent teacher -- dynamic, articulate, engaging, and confident. He could doubtless make any subject interesting, but the topics he covers in this course have intrinsic appeal for a broad audience; no one will fall asleep during the lectures, which are accompanied by readings from Prof. Estrada's excellent textbooks and short weekly quizzes that put the material into practical context. This worthwhile introduction to corporate finance won't make you a CFO but will certainly help you start thinking like one.

This wide-ranging course covers three largely independent technology subject areas and, importantly, key devices that have emerged from them. Prof. Ross begins each topic -- semiconductors, photonics and magnetics -- with a thorough foundational introduction, and then moves on to applications and devices. The semiconductor unit, by far the most rigorous, includes an introduction to diodes, transistors, and photovoltaics. Photonics takes you through lasers, LEDs, liquid-crystal displays, and optical fibers. Magnetics begins with a review of what you learned in freshman physics and chemistry but proceeds to the design of storage devices, some familiar (like disk drives) and some more exotic ("spintronic" media). Prof. Ross's lectures are excellent -- clear, articulate and easy to follow. They represent an online version of the residential 3.15 course and were prepared for MIT students. Prof. Ross has generously made them available through edX, but she did not participate in the edX course itself. Instead, a course manager did an excellent job administering homework assignments and exams, answering our questions, and keeping everything on track. The biggest surprise, for many, was the difficulty of some of the homework assignments and exam questions given the easily followed lectures. While you could always thread back from the answers to a topic covered in lecture, following that thread when actually trying to solve the problem was often quite challenging, even occasionally mystifying. For the semiconductor unit in particular, a textbook is essential. Fortunately, Prof. Chenming Hu has written perhaps the best one out there and offers it free online. In sum, this is a well-presented, well-organized introduction to key topics in materials technology that emphasizes device applications without short-changing the fundamentals.

Although this course picks up where Part 1 left off in terms of topics covered, it's a whole different experience in terms of difficulty. Whereas Part 1 stressed concrete concepts like sorting, searching, and asymptotic analysis, Part 2 soars into the esoteric world of graph theory, NP completeness, and proofs. The algorithms are not so much harder to code than in Part 1, but the data sets may tax the limits of your system -- you may have to find some tricks to simplify the processing in order to get an answer, and those tricks are not really part of the course; you're on your own, with the help of your fellow students. As in Part 1, Tim Roughgarden is an awesome teacher. In fact he's so unpretentiously articulate, and so down to earth, that you may sometimes lose sight of how complicated what he's talking about really is. Don't worry, though, the problem sets and programming assignments will ensure that you've really grasped the material. When you've finished both parts of this course, you'll really have canvassed the landscape -- not only of specific algorithms, their structures and performance limits, but of some foundational questions in computer science.

This excellent introduction to marketing is taught by three eminent professors
from Wharton in separate modules. It is not structured as a comprehensive
overview of basic marketing concepts from A to Z; rather, the course provides
a focused treatment of three highly "actionable" areas, which collectively
cover a solid range of practical, contemporary marketing challenges. Barbara
Kahn gives a broad overview of branding principles and strategies; Peter Fader
covers "customer-centric" marketing methodologies that analyze the customer
base and actively exploit its heterogeneity; and David Bell describes up-to-
the-minute go-to-market strategies that directly confront the challenges of
competition in an online world. (His take on how traditional businesses can
cope with customers who shop in person and buy online is especially
compelling.) The lectures are crisp and professional, and the optional
readings are all interesting and well chosen; it would be a mistake to skip
them. The exams are not difficult if you've studied the material. Overall a
valuable and highly enjoyable course.

This excellent course provides an “end-to-end” introduction to databases – how
they’re organized and how to use them. The breadth of topics covered is quite
broad, and the lectures moves briskly from the mind-bending heights of
relational algebra and set theory to the nitty-gritty details of query
formulation. The latter is really programming, and here the lectures lead you
through “demos” in the how-to style of a corporate training seminar. The
course covers quite a few different programming paradigms and languages: XML,
JSON data, SQL, XPath, XQuery, XSLT, and OLAP. You’ll take a pretty deep dive
into each of these, and there are plenty of exercises that allow you to
develop a working feel for them. But the course also covers database design
theory and more general concepts such as transactions, constraints and
indexes. The class is demanding and there’s plenty of work. There are
exercises, quizzes, a midterm, and a final exam. The exercises are divided
into mandatory “core” sets of problems and an optional set of “challenge”
problems. You can pass the course without doing a single challenge problem,
but it would be a mistake – by and large they’re not substantially more
difficult than the core set, and they really fill out your knowledge of the
subject matter. If all of those somehow fail to slake your thirst, there are
ungraded extra problems as well. You can submit answers to problems and
quizzes as often as you like, with no penalty, though the quiz questions
change with each iteration. On the midterm and final, however, you only get
one submission. The lectures are truly first-rate. Professor Widom is
invariably lively, articulate and engaging, even when leading you through the
technical thickets of the programming demos. Downloadable course materials
include clean and marked slides as well as demo files, which have all of the
code discussed in the lectures. A great advantage to this course is that there
really is no need to purchase a textbook – everything you need is provided.
Staff support, on the other hand, is slim to nonexistent. If you post
questions, they will likely be answered, if at all, by a talented classmate
generous with his or her time. Given that most participants are unfamiliar
with at least some of the material, you’ll find the discussion board to be a
lively place.

MITx has now split its introduction to computer science and programming into
two consecutive seven-week courses. This first installment teaches basic
programming skills and algorithmic thinking using the popular Python language,
taking students through the rudiments of program design, Python semantics, and
debugging. More advanced topics treated toward the end of this course segment
include tree structures and a serious introduction to object-oriented
programming. The course is extraordinarily well designed, beginning with the
textbook – John Guttag’s “Introduction to Computation and Programming Using
Python” is well-written, eminently understandable, and filled with sample code
sequences that make the rubber meet the road. Prof. Grimson’s lectures are
clear and well-organized, although they sometimes recapitulate rather than
supplement or clarify the textbook’s presentation. The video segments are
broken up by progressive “finger exercises” that have you turn what you’ve
read and heard into working knowledge. Each week also includes a problem set,
which is usually a programming task that creates something entertaining – a
game or, most challengingly, a web “scraper” that retrieves news stories based
on combinations of keyword triggers. The programming assignments are also
progressively organized so that you’re writing code modules that perform
specific tasks within a template, not an entire program from scratch. The
autograders are excellent, providing feedback that helps you find the bugs.
The introductory nature of the course notwithstanding, it isn’t easy, nor is
everything you need always in the materials provided; you may sometimes find
yourself searching the web for techniques or resources (of which there are
plenty out there). I didn’t spend much time on the discussion boards, but from
what I saw, staff support seemed disappointingly minimal. Overall, though, the
positives far outweighed any negatives in this superb entry-level course.

Very enjoyable introduction to some basic concepts in modern philosophy, and
to philosophical ways of thinking. The instructors, who changed from week to
week, were invariably engaging and their lectures interesting and clear. My
wife and I would enjoy the lectures over dinner and take long walks discussing
the issues they raised.