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.
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.
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.
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.
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.
One thinks that language does not matter - but it often does. While conceptually they are all the same, Julia, through its performance allows one to achieve high performance without needing to write kernels in C.
When one is writing computational codes to address new problems, one does not always have a library of well-written high performance packages to call. The ability to use a high levels of abstraction, that Julia offers, and then being able to run your programs at scale on heterogeneous hardware, is what makes Julia attractive.
As a result, I am already seeing that Julia is already enabling a large number of scientists and engineers to write libraries and packages, instead of being end users. I believe that these numbers will explode in the coming years and computational science will further establish itself as a credible third pillar of science along with theory and experiments.
Type system, multiple dispatch, performance, parallel programming, homoiconicity, etc (https://en.wikipedia.org/wiki/Julia_(programming_language)#L...).
It's hard to give up those features once you've tried them.
And the syntax is comparable with Python on a simplicity level.
Simple: it's more expressive, allows user defined types, multiple dispatch, performance, etc. And with PyCall.jl you can use every Python library available.
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.
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?
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/) or Alan Edelman's "A programming language to heal the planet" (https://www.ted.com/talks/alan_edelman_a_programming_languag...), 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.
Here's details from a departmental e-mail from mid-July (likely outdated).
-----
Prerequisites:
Students should have a good familiarity with any popular programming language such as Python or R, and ideally have taken or are taking a math class such as 18.02 (multivariable calc).
-----
Contents:
General-purpose Computing, Data manipulation, abstraction, optimization, machine learning, performance, Random walks, graphs, automatic differentiation, differential equations
-----
Format:
We plan to experiment each week with
* 30 minutes of asynchronous lecture (the story)
* Five 6-minute quick video how-tos
* 30 minutes of live, engaging lecture with nongraded quiz questions to test understanding
* 30+ minutes of break-out sessions, help, questions and answers, or discussion
* (Mostly) weekly problem sets
* Letter grading typical of the Fall 2020 semester
* Freshmen are advised to be aware of credit limits and the process to petition
After watching last week's convolutions lecture it seems like 30 minutes is too short. 45 minutes would probably be better. I could probably even listen to Sanderson for an hour.
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?
It's always good to focus on one course. just pick one and go with it. CS50 in particular is very introductory. It made to accommodate basically those who have never heard of programming before.
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.)
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.
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.
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).
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.
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.
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_...