
Introduction to Computational Thinking - guiambros
https://mitmath.github.io/18S191/Fall20/
======
guiambros
I really enjoyed the first week, and it has been a good motivation to start to
learn Julia.

Grant Sanderson's (aka 3blue1brown) lesson on convolutions [1] was simply
excellent. Can't wait to see upcoming lessons. Really amazing that MIT is
publishing these in parallel to the live course.

[1]
[https://mitmath.github.io/18S191/Fall20/lecture2/#segment_1_...](https://mitmath.github.io/18S191/Fall20/lecture2/#segment_1_convolutions_in_image_processing)

~~~
ViralBShah
Note that the Pluto notebooks are not yet posted, but will be after the
assignments are due.

~~~
melling
Is there a site where you can run Pluto notebooks rather than running them
locally?

~~~
ViralBShah
Not that I am aware of. We are working towards that possibility on
JuliaHub.com, but nothing soon. I should point out that installing Julia and
Pluto locally should take at best a matter of minutes and no fuss.

~~~
melling
Locally is often an iPad. That’s why I asked.

------
oshea64bit
It seems like this course is on the bleeding edge of high-quality education --
the use of Julia as the programming language of choice, Discord for
communication, and most importantly 3Blue1Brown as an instructor. Good to see
that innovation isn't dead in academia.

~~~
UncleOxidant
And Pluto notebooks are amazing in this educational context. With Jupyter
notebooks I always wondered, why not just use the REPL? But Pluto's reactivity
brings something new to the table. And being able to easily add UI elements
like sliders bound to variables is something that you can't do in Jupyter.

~~~
bfieidhbrjr
You should buy an old mac from 1984 and put Mathematica 1.0 on it and your
mind will really be blown :-)

------
tikej
Youtuber teaming up with MIT professors is dream come true when it comes to
online learning. Great job!

------
dunefox
I'm glad that courses like these are taught using Julia and not Python. I'll
definitely have to go through this material.

~~~
edanm
Interesting, why is that?

I'm a big Python fan, and don't know anything about Julia really. So
interested in your thinking.

~~~
ChrisRackauckas
One of the reasons is because you can write a fast and scalable simulation
directly in Julia. Something like Python will inhibit the speed of loops,
scalarized nonlinear functions (like in ODEs), and multithreading. You could
try to run an introduction to computational thinking (which is essentially
introduction to computational science and introduction to programming at the
same time) in C++ + Python, but then you spend half of the course teaching
students how to handle C++ and how to link all of their compilation tools, and
all of that is time not spent on the actual topic of the course. At one point
I did this in a numerical analysis course, and it just detracts from the main
message.

But with Julia, the whole course is up and running on day one, and you can
start with building bifurcation plots or agent-based models which then grow in
complexity without having to rewrite for performance. Since these
computational science courses always to try poke at studies of complexity,
this is very essential.

------
snicker7
MIT has been really pushing Julia. This is not their first course using it.

Exciting since MIT use to be one of the few notable universities using Python
for some of their intro level courses -- back when Java and C++ had a
monopoly. I think that much success of Python can be owed to MIT curriculum.

------
sreejithr
Grant Sanderson? Ok im sold

~~~
GreenWatermelon
I winded back and did a double take when he appeared. damn I love Grant. his
Content is awesome.

------
LeanderK
I didn't find an overview of what will be covered in the course and who the
intended target audience is. Did anybody find some infos about this course?

~~~
ViralBShah
The course is really for anyone who has a curiosity in applying computational
science to solving problems. If you are motivated by Victor's essay on "What
can a technologist do about Climate change"
([http://worrydream.com/ClimateChange/](http://worrydream.com/ClimateChange/))
or Alan Edelman's "A programming language to heal the planet"
([https://www.ted.com/talks/alan_edelman_a_programming_languag...](https://www.ted.com/talks/alan_edelman_a_programming_language_to_heal_the_planet_together_julia)),
then you should follow this class.

It does many things differently than the traditional way of teaching such a
course. Specifically the emphasis on applications that matter today
(epidemiology, climate change, etc.) are a key part of the course, where a
more traditional approach may have been to cover a series of numerical
methods.

~~~
igotsideas
Just read "What can a technologist do about Climate change.” Thank you for
posting that. Has me wanting to change what I’m currently working on.

------
srckinase123
For a beginner, would taking this course and CS50 concurrently be a good idea?
Or would learning multiple different programming languages simultaneously be
an unnecessary burden for a beginner?

~~~
wegs
No. It would be a bad idea.

This course looks good. CS50 is overhyped dogshit.

The CS50 lecturer is an egoist, very good at selling you on it being THE
GREATEST COURSE EVER, and convincing you that you're learning REALLY HARD
THINGS. Oh, and you're truly brilliant for learning it, and he's truly
brilliant for teaching it so well that you can understand it. Come join his
cult! And all that time, he's doing a random, disjointed hodgepodge of very
basic stuff.

You can totally do two programming languages simultaneously, but you might as
well go with a good curriculum. Khan Academy is surprisingly excellent. MIT
6.001/SICP will run you over with a steam train, but boy will you learn a lot.
Coursekata will teach you data science in R. There are a whole bunch of really
excellent Python courses, web dev bootcamps, and, well, just really quite a
lot of really good stuff out there.

The hard piece for a beginner is sorting out the wheat from the chaff. But I
just gave you a bunch of pointers. Pick one. Pick five. Run with them. Or ask
someone who is a serious computer scientist to help point you if none of those
match your interests. Just don't ask a person straight out of a CS50
brainwashing; it takes a bit of expertise to be able to look back and see
what's good and what's bad.

(CS50 cult members: Please downvote! And bring your friends.)

~~~
goku99
Very rude and unkind. It's not as if your paying for any of that material.
It's super beginner friendly.

~~~
wegs
1\. Free doesn't excuse harming students.

2\. And it's not all that free. It's a growing business founded on hype and
freemium. CS50 peddles it's wares on edX for $180 per "program," and it's
being monetized quite a few other places.

3\. Beginner-attractive isn't the same as beginner-friendly. Ice cream is
beginner-attractive to kids first learning to eat, but vegetables are
beginner-friendly. With CS50, you'll waste a ton of time to, ultimately, learn
very little and be convinced you've learned a lot. You'll definitely learn the
slogan "This is CS50" with an impressive video montage, though, and that
you're part of an elite crowd which managed to master Scratch.

This is the bane of self-driven online education. People shop based on novice
perception.

Or, guessing from your one-comment account, you're a David Malan cult member
who signed up just to post this one comment. In which case, good job! You got
out of CS50 what David was trying to teach you. Carry on. Bring your friends!

If you're not, have an objective look inside. Tell me it doesn't look like a
"free" Scientology audit.

~~~
goku99
Look, Personally I have only seen first 4 videos. They were kinda good, but
they were too slow! however I am thankful for those first few videos, they
were quite helpful if providing a bird view of programming world. They might
have been sillier at times. But that's just how it is, it's supposed to easy
for others to jump in. This was way back when it was initially launched. Don't
criticize content providers personally, you disagree with content however.

------
Protostome
I don't understand why people choose niche programming languages for such
courses. Why not choose a language that most people know and fluent with.

Now in addition to learning the course material I have to learn a programming
language I will never use again, great

~~~
ddragon
It's not really a random choice in this case, Julia was created on MIT, and
this is an MIT course. It's also free and open-source unlike it's competitor
Matlab. It's also a very appropriated language for the theme considered it was
designed by and for mathematicians and physicists (even if it targets beyond
those areas). And it's not like it's going very deep on the language.

But most importantly, it's a good idea to learn many programming languages
even if you think you're not going to work with them. Each language teach new
concepts (immutability, OOP, monads, ownership, macros and in Julia's case
multiple dispatch in particular) that not only increase your repertoire of
abstractions and ways to understand and solve a problem, but they also allow
you to quickly move between languages when needed (for example if you find a
nice job that happens to use one of those "niche programming language", which
was my case with Elixir).

~~~
Protostome
Python is a very well established programming language with plenty of support
for scientific computing. If the course authors would like to make the course
accessible to as much people as possible, there are very few reasons to choose
languages which are not widely adopted.

~~~
ddragon
I answered above on a general sense, but this course is Introduction to
Computational Thinking. First it's an introduction course, so it's not
required experience with any language (you have lessons explaining arrays for
example). Second it's a theoretical course (computational thinking, not
something like applied data science), not a practical one, so that support is
not important here since things are being written from scratch (the second
lesson is about convolution, and the exercise is writing the convolution
function). You can probably agree that simply using numpy.convolve wouldn't
teach as much as writing your own, and writing in Python would end up too slow
for the larger images used unless you use Numba/PyPy/Cython (or make less
pseudo-code version by vectorizing everything in numpy), all stuff that is not
very introductory level.

And Julia does have features besides speed that makes the course better for
beginners, for example native multidimensional arrays. Images are just
matrices of RGB pixels that you can freely manipulate like you would Python
arrays (without the need to learn a library like numpy or any kind of
conversion). And Pluto.jl reactive nature allows you to have immediate
feedback of everything you change.

