How to be a better programmer?! Try non-Algol Languages

How many programming languages do you know? ASM , Basic,C,C++,C#,Pascal, Java, Javascript , Scala , Rust

Oki and how many languages you know outside of Algol-like style? So on practice, we all over and over again re-learn Algol

How many minds shift paradigm languages you know?

I see a big renaissance in a language now we have a good old friend back LISP -Clojure, Erlang -Elixir, Ocaml — F#, ReasonML, scala, Smalltalk — Pharo, VisualWorks, gemstone

It is a few languages that will help you to be a better programmer

So let’s take a look at some

Smalltalk

1) Smalltalk (Pharo https://pharo.org/) — It was mind shift language. First pure OO language inspired by lisp and Modula. The power idea that parts have all power and characteristics of the entire system. So the center of all is an Object and the object communicates via the messages.

But really mind-blowing idea is an Image-based environment and IDE — you should try it. It is much bigger than a repl. You are part of a live system of connected life objects and even a compiler is a part of this system

and Syntax of language could be printed on a postcard. it is super small.

More could be found here

Getting The Message

Why learning Smalltalk can never be a waste of time

How learning Smalltalk can improve your skills as a programmer

LISP

One of the oldest languages. Was designed for AI and research. It is just the implementation of math lambda calc as is. But the main mind shift is the symbolic programming and homoiconic — so code is data and data is a code. What’s more interesting your program could analyze and extend itself. So the famous lectures — Structure and Interpretation of Computer Programs is done with Scheme — the Lisp dialect

So the most beautiful program is lisp interpreter written on the racket

(define eval-expr (lambda (expr env) (pmatch expr [`,x (guard (symbol? x)) (env x)] [`(lambda (,x) ,body) (lambda (arg) (eval-expr body (lambda (y) (if (eq? x y) arg (env y)))))] [`(,rator ,rand) ((eval-expr rator env) (eval-expr rand env))])))

Clojure

Amazing Data Management system — Immutable DB

Datomic - Overview

One more interesting folks in a room is Racket — a lisp that allows to implementation of languages as libraries. so it is a Language Oriented Programming

Racket

Forth

Forth ( https://www.forth.com/forth/) is a stack-oriented unique language. so you have an interpreter, compiler, and operating system in the same box.

It is a de facto language for microcontrollers and embedded systems. The mind-shift idea here is pointer-free factoring and self-extending. So you create with every few lines words that immediately extend a language dictionary. So line by line you create a DSL and turn simple system language into a full-scale high business-oriented system

Execution of Forth Code

Summary

All these 3 languages have one common pattern in a core. So a syntax itself and constructs of language is super minimal and reduces noise and a cognitive load but instead forces the developer to build a DSL and proper domain model and turn the program to extremely focus on a domain.

One more observation on these 3 languages — one data structure in a core. so sometimes less mean more.

• smalltalk have Object
• Lisp — lists ( Clojure have a power of bit vector)
• Forth — stack

As a result, a simple and domain-oriented language with a full focus on the problem not on the language itself

Published By

Originally published at https://www.linkedin.com.