DmitrySoshnikov

mangatmodi, great, thanks! Feel free to reach me in case of any questions, and good luck with memory management -- it's a great engineering topic.

Hey ameyv, awesome, thanks! Will appreciate your feedback on the course page.

Now available on Teachable as well: https://dmitrysoshnikov.teachable.com/p/essentials-of-garbag...

Available now on Teachable as well: https://dmitrysoshnikov.teachable.com/p/essentials-of-garbag...

Available now: https://dmitrysoshnikov.teachable.com/p/essentials-of-garbag...

Yeah, creating a course there now :)

Thanks! Yes, Udemy provides sending messages to instructors, though I'm not sure about specifically community per course. You may also contact me directly on Udemy on my website in case of any questions.

I'll see if I can just put the course on another platform with stable prices. Maybe even on vimeo or something, so it's possible to buy just individual lectures to be more flexible. Though, if you got a good price now from Udemy, this probably works too.

Yeah, I should probably just set the fixed price for future course (didn't know Udemy such aggressively drops the prices back and forth). Though, it'll be 114.99 for the original price, so it's great you were able to win this lottery for 10.99 :)

Plus, the one which will be the actual companion book for this course (the same 16 chapters as a book with more details) -- "Essentials of Garbage Collectors", and which I'll try adding soon.

Yes, the main book which is recommended for the course is "The Garbage Collection Handbook". In addition one can read the "Garbage Collection: Algorithms for Automatic Dynamic Memory Management", but this one is specific to C++.

Interesting.. I clearly remember the opt-out checkboxes when I was creating the course, but I don't see them anymore neither in the course, nor in profile settings. I can only change the price, but not to opt-out from the price drops. Will clarify with Udemy support.

As mentioned above in other comments, Udemy was just easy to setup, and doesn't have monthly subscription fee. In general I'll be fine with the fee, so I'm considering other platforms for this and future courses. Let me know if you have good recommendations.

Absolutely valid point, that's why I didn't want to stick specifically on C++ (even though it'd be easier specifically for raw heap memory).

As mentioned about though, GC algorithms can be transferred to higher-level system as well. For example, here is a basic Mark-Sweep algorithm implemented in JavaScript on JS objects in a collection: https://gist.github.com/DmitrySoshnikov/4391763

Great point, and the example. Exactly, the GC algorithms are a high-level abstraction, which can be transferred, and applied on higher-level systems.

Thanks, yes, all the lectures on GC algorithms (from Part 2 of the course) have a detailed source code implementation. This is done is pseudo-code though, explicitly showing that you can port this implementation to any language you'd like.

As mentioned below in this comments thread, GC algorithms are not only specific to objects in raw heap memory. These algorithms are transferrable to higher-level systems as well.

As to specific implementation, yes, I'm planning to have a GitHub repo with all the algorithms implemented in C++.

Yes, that's a good question about Udemy's policies. I was also surprised it's got on massive sale right after publishing, lol. I'll consider publishing it on other platforms as well. Do you have good recommendations?

It's actually a good question. Udemy was just easy to setup, and with no subscription monthly fee. I'm considering cross-publishing it on other platforms as well. I'll be OK in general with monthly fees for publishers once I have several courses. Do you have suggestions for better platforms?

Good point, I should take a look if it's easy to just opt-out. I'd be OK with these discounts in general, though they look really weird -- the course was just published, and is already "on (massive) sale" :)

Yeah, this is something I completely agree about Udemy's policies. Alas, as you say, I unfortunately don't have any control over their price changes.

@ameyv, thanks for the feedback!

Yes, there will be more courses related to implementation of programming languages: Automata Theory, Theory of Parsing, Essentials of Interpretation, and others.

There are some lab sessions for the Garbage Collectors class, e.g. Writing a Memory Allocator from Lecture 6, where we implement an allocator similar to `malloc` function: http://dmitrysoshnikov.com/compilers/writing-a-memory-alloca...

As to materials, yes, there will be an accompanying book for this course.

Exactly, Python is a "prototype-based" language with first-class classes as sugar; similar to Coffee. I gave a link below where kinds of classes are described.

> Thanks for the comment. I have added big red (orange ...) boxes to let the user know that it is considered bad practice

Guys, don't spread ignorance.

Implementation details aren't essential, therefore a "bad practice" in this respect is just an ignorance.

Once again: the difference between classical and prototype-based (delegation-based in this case) inheritance is _ideological_.

In first case (classical) we have systematized (classified) code reuse, in the later (prototypal) -- unclassified (or "chaotic") code reuse, i.e. "I reuse/inherit the behavior and state from that object from which I want".

There are no other differences. The implementation details are derived stuff. Moreover, the same implementation can provide both, classical and prototypal _approaches_ of a code reuse (good examples: Python - prototype-based language, CoffeeScript, JavaScript, etc). Because a "class" isn't a syntactic construct, inst' some specific implementation. It's the _ability to classify_ objects. And this ability can be achieved in different systems regardless an implementation.

So if you need a classical code reuse with predefined "shapes" of your objects - you build a classical system reusing the code form linear ("tower") chain of inheritance. If instead you need just reuse a small functionality regardless of the classical hierarchy -- you use prototypal inheritance, that is delegation based traits/mixins/prototypes. And JS has both of them -- classes (without sugar) and prototypes -- and they both can be used when needed, there is no "bad practice" in this case.

Regarding classes and their kinds (that's why Python is also prototype-based langauge with "classes as sugar", the same as in Coffee, the same as is planed for ECMAScript): https://gist.github.com/977034

You may find additional info on common theory of OOP and in particular in ECMAScript with all details in "ECMA-262-3 in detail. Chapter 7.1 / 7.2".

Dmitry.