Is Smalltalk worth learning in 2020?

Yes, it is worth learning in 2020 because it is still very relevant. The universal consensus is that Smalltalk is the best OOP language. It was the first programming language to promote OOP back in the 1980s. It has directly motivated the design of nearly every OOP language we use today, including Python, Ruby, PHP, etc. Since OOP is so widely used throughout the IT industry, it is the best way to lay a solid foundation and provides the base for object-oriented programming before moving to other languages.

There is always something new to learn.  Click this affiliate link to register for Python Certification training.

Languages like Python and JavaScript, and C were never considered nor intended as teaching languages. There are developed languages that carry a lot of baggage. No matter how friendly you think Python and JavaScript are, if you are a beginner, you must start with Smalltalk. In the course of your career, you will likely learn and use many programming languages. You can learn Python or JavaScript afterward, and there is nothing wrong with this strategy. You don’t have to use Smalltalk in production today, but try to code something in Smalltalk and see how it feels. It should feel familiar because Smalltalk’s implementation of the object-oriented (OO) standard is so excellent that it has influenced an entire generation of OO languages, such as Objective-C, Python, Ruby, Erlang, CLOS, PHP 5, Perl 6, Swift, Groovy, Scala, Dart, and so on.

Click this affiliate link to register for PHP & MySQL with MVC Frameworks Certification Training and gain even more industry expertise.

By learning Smalltalk, you’ll understand how all of those beneficial features in today’s OO languages came to be. Learning Smalltalk could also give you a big advantage in programming skills among your peers, and it could be a great tool for teaching programming to beginners. It’s one of the most productive development platforms in history, having several mature applications, and there’s a surprisingly large codebase out there.

Is Java your thing?  Click this affiliate link to register for Comprehensive Java Course Certification Training.

Features of Smalltalk programming language:

• Smalltalk presented the world to the language virtual machine (VM), which allows the software to be platform-independent. This is the same technology that supports Java (JVM), Android, etc.
• Smalltalk also founded JIT or just-in-time compilation, a technique for intensely improving the performance of byte code software such as Java.
• Smalltalk bought the first modern IDE or integrated development environment, which comprised a text editor, a class browser, an object or property inspector, and a debugger.
• Smalltalk has closures, scoped as first-class functions. In short, a closure is a callback function that can see non-local variables in the place where they were defined. This can help in writing more compact and readable code.
• Smalltalk was the first language tool that supported live programming and advanced debugging techniques, such as on-the-fly inspection and code changes during execution. Today, live debugging is possible in C# with Visual Studio’s edit-and-continue feature and with Hot-Swap in Java.
• Smalltalk introduced MVC to the world. It is a software architectural pattern for executing user interfaces. It’s common with desktop graphical user interface (GUI) and web applications.
• To a large extent, Smalltalk is accountable for giving us test-driven development (TDD) and extreme programming (XP), which are both very significant in today’s standard agile practices.
• Smalltalk made duck typing a household term. Duck typing is where type checking is delayed until run-time or when reflection capabilities are used to ensure correct behavior. We can find duck typing in many languages today.
• Smalltalk pioneered the growth of object databases. While it didn’t become normal, object databases have their niche markets. The best example of an object database product is Gemstone S, which is well-suited to scalable, high-performance, multi-tier distributed systems.
• Smalltalk provides the first refactoring browser.Smalltalk provided the GUI and” what-you-see-is-what-you-get “(WYSIWYG) user interface.

Smalltalk Programming Language Examples:

GNU Smalltalk:

A free implementation of the Smalltalk-80 language, which runs on most of the versions on Unix and, in general, everywhere you can find a POSIX-compliance library is GNU Smalltalk. It is well-versed in scripting tasks and headless processing that is an uncommon feature of it.

Pharo Smalltalk:

A pure object-oriented programming language and powerful environment focused on simplicity, and immediate feedback (think IDE and OS rolled into one) is Pharo. It has a simple syntax.

Amber Smalltalk:

Live development environment with a class browser, workspace, unit test runner, transcript, object inspector, and debugger included in Amber.

Squeak Smalltalk:

Smalltalk programming system with fast execution environments for major platforms is Squeak. The framework, which promotes low-effort graphical, interactive application development and maintenance, is featured by it.

Cuis Smalltalk:

A free Smalltalk-80 environment originally derived from Squeak with a specific set of goals, i-e being simple and powerful is Cuis. It is portable to any platform, fast, and efficient. This means it is a good tool for running on any hardware, extending from RasPi’s and the like and phones, including regular laptops and PCs up to server racks and everything in between.

Dolphin Smalltalk:

An implementation of the Smalltalk programming language for Windows is Dolphin Smalltalk, Dolphin for short. It uses an integrated development environment. The toolkit of this Smalltalk dialect include an integrated browser, a WYSIWYG “view composer,” and a package browser.  From the convention of the Smalltalk MVC framework with the choice of a Model–view–presenter framework, it deviates.

Hoot Smalltalk:

A new variant of this venerable language Hoot Smalltalk. Hoot supports optional type annotations. Separate namespaces are supported by it. Hoot runs on the JVM and can share Java’s wonderful ecosystem. A much-needed piece of Smalltalk’s future is Hoot.

Smalltalk Code Examples:

If Statement:

“Smalltalk if statement” time > 120

ifTrue: [Transcript show: ‘Time expired.’; cr. time := 0]

ifFalse: [Transcript show: ‘Time remaining: ‘, (120 – time) printString, ‘ minutes’; cr]

Calling into C library:

unixModuleName

^ ‘ffilibc.so’getBuffermem

^ self ffiCall: #( uint get_buffermem() )getCachedmem

^ self ffiCall: #( uint get_cachedmem() )getCpuCount

^ self ffiCall: #( uint get_cpu_count() )getCpuFreq

^ self ffiCall: #( uint get_cpu_freq() )getCpuTemp

^ self ffiCall: #( float get_cpu_temp() )getCpuUsage

^ self ffiCall: #( double get_cpu_usage() )getFreemem

^ self ffiCall: #( uint get_freemem() )getFreeswap

^ self ffiCall: #( uint get_freeswap() )getFsAvail

^ self ffiCall: #( uint get_fs_avail() )getFsTotalsize

^ self ffiCall: #( uint get_fs_totalsize() )getMachine

^ self ffiCall: #( String get_machine() )getNodename

^ self ffiCall: #( String get_nodename() )getNumprocs

^ self ffiCall: #( uint get_numprocs() )getRelease

^ self ffiCall: #( String get_release() )getSysname

^ self ffiCall: #( String get_sysname() )getTotalmem

^ self ffiCall: #( uint get_totalmem() )getTotalswap

^ self ffiCall: #( uint get_totalswap() )getUptime

^ self ffiCall: #( uint get_uptime() )getVersion

^ self ffiCall: #( String get_version() )

MyStringMorph class: StringMorph subclass: #MyStringMorph instanceVariableNames: ‘block’ classVariableNames: ”

poolDictionaries: ” category: ‘Cranky’

 InfoLine class:

Object subclass: #InfoLine instanceVariableNames: ‘label info’ classVariableNames: ” poolDictionaries: ”

category: ‘Cranky’

Cranky class:

Object subclass: #Cranky

instanceVariableNames: ‘m s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12 s13 s14 s15 s16 s17 s18 s19’ classVariableNames: ”

poolDictionaries: ” category: ‘Cranky’

      Initialize

| f |

f := Form fromFileNamed: ‘hot_air_balloon_mysticmorning.jpg’. m := ImageMorph new.

m form: f.

self initSystemfields. self initMemoryfields. self initSdCardfields. self initCpuFields.

(m openInWindowLabeled: ‘Cranky’) location: [email protected] “place in top-left corner of Pharo window”

To generate the core application window for this, you create an instance of #Form from a balloon image file, then set it as the image in the recently created imagemorph using the form: message.

 Pharo Smalltalk:

Pharo is a simple & powerful language having an advanced run-time reflection. It has a pure object-oriented approach and simple language syntax. Pharo has closures with non-local returns and has immediate objects identity swapping. It consists of live customizable object inspection. It involves dynamic inheritance and a virtual machine written mostly in the language itself. Other features involve easy call stack manipulation, fast objects enumeration, customizable meta-classes, and relatively low memory consumption.

The UI of Pharo behaves the same way on all platforms. The compiler is written in Pharo, and you can adjust it as anything else in the system. One can use completely different compilers for some of your classes. Pharo provides users with moldable development tools. All objects in the system can be kept at once in a platform-independent file named image. So one can save the complete state of a program during debugging and restore it to try to find a different execution path or other solution.

Pharo has advanced integrated Git support that goes beyond the standard level of files. One can merge branches on the granularity of particular methods, browse their history, create pull requests directly from the IDE, and so on. It has fast object serialization. Pharo can use fractions, large integers, and scaled decimals, and so on to work with numbers without losing arithmetic precision. It provides a simple connection to native libraries. It can easily create proxy objects – objects that process and/or resend all messages to another object, which is vital to object-oriented languages.

In Pharo, the programmers have absolute freedom to modify the system and use many potentially dangerous features. On the other hand, most programmers will use them with consideration because Pharo provides a powerful standard library and tools describing the right way to use the system.

Python vs. Smalltalk

Python is a cool language to learn, having many applications. That’s why it’s so common. But guess what? Smalltalk is even easier! Smalltalk is one of the simplest programming languages around the globe. It virtually consists of no syntax. Every task is completed by message passing, including control structures like if statements and loops. Some people may find Smalltalk’s message-passing syntax a bit troubling, but some people also find Python’s indentation-sensitive syntax just as troubling, if not more so. At least, Smalltalk syntax will never get you into anxiety (in a way that a misaligned piece of Python code might).

Additionally, while Python is easy to learn, it also carries with it a great deal of baggage from time to time of real-world usage. By comparison, Smalltalk has very few usability issues. After more than four decades, Smalltalk has managed to remain as clean and pure as the driven snow! Even while the language has gone through a significant improvement, developers describe Python as a clear and influential OOP language, comparable to Perl, Ruby, Scheme, or Java.

Get ahead in your career as you keep learning.  Click this affiliate link to register for Ruby on Rails Certification Training.  

Python is most admired for its well-designed syntax and readable code. If you are just beginning your programming career, Python will suit you the best.

On the other hand, Smalltalk is completely an object-oriented programming language. It was created as the language supporting the “new world” of computing demonstrated by “human-computer symbiosis.” It was designed and created for educational use, specifically for learning.

The major difference between both is Python’s more “mainstream” syntax, which provides an upper hand in programmer training. Python has built-in object types from user-defined classes and presently doesn’t allow inheritance from built-in types. Smalltalk’s standard library of

Collection data types are more developed, while Python’s library has more facilities for dealing with the Internet, WWW realities.

What is the easiest coding language to learn?

Smalltalk is a programming language based essentially on the concept of message passing. It was designed as a small, easy-to-learn language compared to the substitute languages of the time. In the early 1970s at Xerox PARC’s (Palo Alto Research Center Incorporated) Learning Research Group development of Smalltalk began, led by Alan Kay, which makes it roughly as old as C. Smalltalk is considered as one of the first object-oriented programming languages and one of the most powerful and most modern languages, such as C++ and Java have imitated many of the concepts of Smalltalk. As an object-oriented language, the main focus in its development was the idea of objects. Everything is an object is a usual phrase in Smalltalk. Smalltalk in itself is precisely not just a programming language but a complete operating system; of course, the operating systems in the 1970s were simpler than today. It was also the first candidly Integrated Development Environment (IDE). The latest stable version is always considered when mentioning Smalltalk as a programming language.

Smalltalk relies on three core ideas: the concept of objects, sending messages to objects, and receiving messages from other objects.

The idea of objects is considered Smalltalk’s most important aspect. Smalltalk is considered a pure object-oriented language. This means that even the basic earliest types, such as integers and characters, are handled as objects. This even allows for, most importantly, the implementation of these main features.

The official and formal Smalltalk language was only developed until 1980, which is when Smalltalk-80 version 2 was released. However, since the 1980s, there are multiple newer Smalltalk implementations and standards that remain in vital development; for instance, ANSI Smalltalk considered the current Smalltalk standard from 1998, GNU Smalltalk, and Squeak.

Which language is best for beginners?

The language having no diversion from the chief goals, saving difficult matters for later, constructivist learning such as plainness, learning by doing, blend of languages (the support of multiple programming paradigms can be powerful for mature programmers, there is always a chance of confusion for the beginner). Beginners do not know which of the ways possible to achieve something to choose and cannot distinguish issues, normal learning difficulties). The importance of debugging should be considered as learning environments should include a good tool for correcting and that students should be taught debugging skills as early as possible.

Actually, there is no reason why students should not be able to find a piece of software before they are able to write one themselves. Thoroughly grasping how selected examples work is good preparation for the construction of self-made solutions.

The single term Smalltalk refers to a trio of an object-oriented language, an exhaustive class library, and a development environment. Smalltalk was developed with developmental psychology in mind and was actually used by children during its development. Programming through Smalltalk was supposed to be a natural addition to thinking. For instance, the use of keyword parameters instead of a meaningless parameter list in parentheses states this intention. Smalltalk has a comprehensive library, interactive environment, built-in debugging facilities, persistence support, and has an adaptable environment.

In Smalltalk, clarity rules are simple. Attributes are secured, and methods are public. Methods are often distinct as private with comments, but no tool support is there. Clearly, there are languages with a more efficient run-time model than Smalltalk, yet, for an educational context, raw implementation speed is not a consideration and has not averted Java, which relies on explicated byte code as well, to be widely used as a first language.

Conclusion

This article discusses Smalltalk and its features in detail. In short, Smalltalk refers to a trio of an object-oriented language, an exhaustive class library, and a development environment. Smalltalk was developed with developmental psychology in mind and was actually used by children during its development. Programming through Smalltalk was supposed to be natural addition of thinking. For instance, the use of keyword parameters instead of a meaningless parameter list in parentheses states this intention.

Smalltalk has a comprehensive library, interactive environment, built-in debugging facilities, persistence support, and has an adaptable environment. Smalltalk is a programming language based essentially on the concept of message passing. It was designed as a small, easy-to-learn language compared to the substitute languages of the time. In the early 1970s, at Xerox PARC’s (Palo Alto Research Center Incorporated) Learning Research Group development of Smalltalk began, led by Alan Kay, which makes it roughly as old as C.

Smalltalk is considered as one of the first object-oriented programming languages, and one of the most powerful and most modern languages, such as C++ and Java, has imitated many of the concepts of Smalltalk. As an object-oriented language, the main focus in its development was the idea of objects. Everything is an object is a usual phrase in Smalltalk. Smalltalk in itself is precisely not just a programming language but a complete operating system; of course, the operating systems in the 1970s were simpler than today. Smalltalk takes everything as objects.

The objects can have different classes, much similar to the modern object languages. It also a full support for subclasses, and in the end, all classes have the same progenitor, the Object class itself. Smalltalk relies on three core ideas: the concept of objects, sending messages to objects, and receiving messages from other objects.