Smalltalk vs ASP.NET MVC

You can modify the system as it's running. You're "swimming with the fish", instead of probing a black box by remote control.

Programmers must make detailed mental models of the system they are developing. Bugs usually happen when the mental model does not match the actual system. This is one of the greatest difficulties beginners have because most systems are so opaque. It takes a lot of effort to see what's really going on. But in Smalltalk this is much easier, thanks to the powerful tools included in the environment, like the object inspector.

All tools (Inspector, Browser, Debugger etc.) are written in Smalltalk and are live objects in the environment. All sources are present, so that the tools can easily be studied, changed and experimented with.
The same goes for the other components like the compiler, OS-Integration etc.

Smalltalk is one of few languages that are purely object oriented. This provides a solid and easy to understand base on which to learn object oriented programming, the most popular approach to programming.

The syntax was designed to be easy enough for children to learn. Beginners can learn the language rules very quickly and then focus on programming without fighting the syntax at the same time. Things that have to be baked into the grammar in other languages are simple message sends with block arguments in Smalltalk. Expressions have only three precedence levels to worry about.

Smalltalk had the original (and still the best) unit test system that inspired it in many other languages (like Java's JUnit). Working with interactive live objects in Smalltalk style TDD makes it easy to teach and learn TDD.

You can edit code and swap it in while the program is still running after an exception has already been signaled, or restart from anywhere in the call stack. You can inspect and modify the state of any object. Some Smalltalkers write unit tests and then program exclusively in the debugger.

You can explore how everything works easily.

Smalltalk provides an extremely fast code-compile-run-debug cycle. You don't have to stop and reset the world to tweak your program, since you can compile one method at a time while the environment is still running. This is great for beginners to experiment and prototype ideas.

MIT licensed implementations Pharo, Squeak, Cuis & Dolphin
and GPL licensed GnuSmalltalk.

A Smalltalk environment can save the state of a running program and later restore and resume execution. This includes the internal state of live objects, multiple thread stacks, and debugging sessions, making it easier for beginners to take the exact problem to an expert for assistance.

This leads to a very simple programming model (pure OO) that is still very powerful. A lot of stuff that is hard to implement in other languages is easier in Smalltalk.

Beginners are usually stuck making command-line applications in other languages, because GUIs are too hard. Smalltalk GUIs are easy enough to start with.

Also known as "blocks". These objects contain reusable snippets of code and as first-class objects they can be passed as arguments to other methods or blocks and also returned from them. "lexical closures" mean they retain access to the variables in the lexical environment they were written in, that is, in the surrounding code.

Smalltalk is the inventor of Just-in-Time compilation and the MVC concept, refactoring through their so-called refactoring browser and it was also one of the first adopters of a language virtual machine, closures, live programming, test driven development, an IDE and the development of GUI`s.

Hybrid languages (e.g., Java, C#, C++) make it easy to slip into procedural thinking. Smalltalk's pure OO approach makes it hard not to think in object-oriented terms. In addition, since the entire IDE and runtime components are there in the image for you to browse, you have plenty of examples of good OO design to learn from.

Many languages today use object orientation, while the most of them stock on the half way in that perspective.
Smalltalk sees literally everything as an object and this includes things like the classes and primitive data types. There is are zero control structures such as selection and iteration, since all is done by sending messages to objects.
It use a lot of concepts from Lisp in order to provide a nice experience for this pure kind of object orientation.
It provides immutable data structures, closures, anonymous functions and higher order functions, while all those functions are objects. This is what makes Smalltalk so simple, elegant, and easy.

All this counts for Pharo, while other implementations as Amber are probably feature complete to it.

The framework has many build-in tools, and many packages have been written targeting the framework.

.Net Core can work on any platform.

It's pretty easy to find a job with it and there's plenty of documentation and tutorials around.

There are a lot of resources available to get help.

Asp.NET Core on Linux is fast accordingly to TechEmpower benchmarks.

You can get ordinary details quickly but with complete freedom to make your craft, knowing everything that is happening underneath the cloths. The highly modular system makes it possible to scale small applications to large ones with ease.

Getting your next contract is easy with this on your CV.