

Complex analysis might just be my favorite field of mathematics. It is a field steeped in
elegance, and it makes it apparent that calculus was always supposed to be done on the complex numbers. 


You must be stupid to think that real analysis is better than complex
analysis. In real analysis, functions can be not differentiable, but in complex analysis,
if a function is once-differentiable, it is infinitely differentiable. Also, if you know
a complex function on an interval, you know it for all numbers.

Contour integral









Complex Analysis is Super Cool


In recent years, we've seen a lot of hype around machine learning. From [alpha go](https://deepmind.com/research/case-studies/alphago-the-story-so-far), which beat world-champion go
players, to [GPT-3](https://en.wikipedia.org/wiki/GPT-3), the constant news buzz
would make one think we are around the corner from [AI Dominance](https://en.wikipedia.org/wiki/Technological_singularity). But I claim today that most of AI is just hype, with no
real substance behind it. Of course time will tell the true use of AI. In fact, most
times teams eagerly throw a [neural net](https://en.wikipedia.org/wiki/Neural_network) at
a problem, they are really looking for a symbolic manipulation tool like [prolog](https://en.wikipedia.org/wiki/Prolog).

# Black Boxes

The first drawback of machine learning is they are incomprehensible. If a machine learning model
makes a mistake, how will you figure out what went wrong? There is no real way of knowing. Sure,
you can look at the internal state of the model, but what does that really tell you?
Models today are getting so large that it is impossible to hold a single one in your
brain. GPT-3 has [175 billion parameters](https://www.springboard.com/blog/data-science/machine-learning-gpt-3-open-ai/#:~:text=The%20largest%20version%20GPT%2D3,and%203.2%20M%20batch%20size.&text=Shown%20in%20the%20figure%20above,that%20it%20is%20quite%20larger.)
parameters. What if it makes a mistake? Will some engineer have to go through all
175 billion parameters just to find it? I think the true solution is [declarative](https://en.wikipedia.org/wiki/Declarative_programming) software
that simply states rules or definitions. That code is easier to debug and understand for
new users. In essence, we can only look at machine learning as a black box.

# Changing Requirements

Often in software engineering, projects are subject to [changing requirements](https://rebelsguidetopm.com/help-the-requirements-keep-changing-and-i-cant-nail-them-down-part-2/).
What happens when this is done to a machine learning model? In short, I don't
see how a machine learning model trained for one task can be fixed to work on
a slightly different task. It would require a whole new retraining of the model
every time you want to make a change. Google even spoke about this issue in their
paper [Machine Learning:
The High-Interest Credit Card of Technical Debt](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43146.pdf). In our ever-changing world, you must truly
consider if you want to use a technology that requires so much effort even to change
its purpose slightly.

# Declarative Programming: is it Nirvana?

I am a huge fan of declarative programming, whether from the [Wolfram Language](https://en.wikipedia.org/wiki/Wolfram_Language) or from [Prolog](https://en.wikipedia.org/wiki/Prolog).
In such a style, the programmer simply states the rules of the system formally, and
the language takes care of implementation concerns. This approach is easy to understand
because it is just the rules of the system. In addition, it is easy to understand
the behavoir of a program: just follow which rules it applied.  If you have never
heard of prolog, I strongly encourage you to check it out. It is unlike any other
programming language, not part of the C or ALGOL lineage. It will rethink the way
that you understand the purpose of computers, [so try it out](https://swish.swi-prolog.org/).

I don't understand the hype around machine learning

Machine Learning is overrated




I recently looked at [A Talk by Bob Martin](https://www.youtube.com/watch?v=P2yr-3F6PQo) in which
he says that we've "basically discovered all the programming paradigms". He says this due to his
view that programming paradigms are just restrictions on what programmers can do, but I disagree.
My view is that **a good programming language is the minimal amount needed to add to a model
of computation**. I will explain what I mean.

## Models of Computation
According to Wikipedia, a [Model of Computation](https://en.wikipedia.org/wiki/Model_of_computation) is
"a model which describes how an output of a mathematical function is computed given an input".
There are a list of models of computation on the page, which include
- Post machines
- Pushdown automata
- Register machines
- Random-access machines
- Turing machines
- Decision tree model
- Abstract rewriting systems
- Combinatory logic
- General recursive functions
- Lambda calculus
- Actor model
- Cellular automaton
- Interaction nets
- Kahn process networks
- Logic gates and digital circuits
- Petri nets
- Synchronous Data Flow

As you can see, there are many models of computation.
## Minimal Addition
What do I mean by "minimal additon". Well, a model of computation only describes mathematical functions, which are pure. We would like our programs to be able to interact with the outside world. This means
some abilities must be added to a model of computation in order to allow interaction. The gold
standard for this is [Haskell](https://en.wikipedia.org/wiki/Haskell), with its monadic model of computation. In a good language, effects should be modelled using some kind of language construct, such
as Haskell's monads, but I think the construct will vary for each model of computation.

## Examples of Well-Loved Languages

I will show how the best-designed languages today are simply the minimal additions to already good
models of computation.


| Model of Computation| Language|
|--------------------|----------|
| Untyped Lambda Calculus | Lisp|
| Typed Lambda Calculus | Haskell|
| Predicate Logic | Prolog |
| Rewriting System | Wolfram |
| Actor Model | Smalltalk |
| Interaction Nets | [Kind2](https://github.com/Kindelia/Kind2) |
| Combinatory Logic | APL | 

Hopefully you see that all the languages on the right column are widely admired for being well-designed.
And what unifies them all? They are all strictly based on a model of computation.

Let us discuss the example of Lisp. Lisp is the [minimal wrapper](https://news.ycombinator.com/item?id=29950782) on top of the untyped lambda calculus. It does not include any features
beyound unleashing the inherent power of the lambda calculus. This is the main difference
between Smalltalk and Java. Both are based on the [Actor Model](https://en.wikipedia.org/wiki/Actor_model)
but Smalltalk sticks truthfully to its model of computation, while Java confusedly
borrows concepts from other languages.

## Turing Completeness
Due to Turing Completeness, we can say that all models of computation are equally expressive.
So, it remains to be decided what model we should use. I think we should first choose a model
that is the best for our needs.

## Good Models of Computation
Given all these models of computation, which should we chose as a basis for our languages?
I think it comes down to 2 critera:
- being simple
- having nice properties

For the first point, I think the model should be very simple. I think the [SK Calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus) is very good in this regard, and it might be the simplest model
of computation that I have ever seen. Turing Machines, although the most well-known example of
a model of computation, are actually very complex and hard to explain. 

For the second point, I mean that the model has properties that make it easy to implement and
fast to run on our given hardware. One model that is very promising is [Interaction Nets](https://en.wikipedia.org/wiki/Interaction_nets#Properties) because they have these properties

- locality (only active pairs can be rewritten)
- linearity (each interaction rule can be applied in constant time)
- strong confluence 

These properties would make an implementation very fast, so I encourage you to try writing
an implementation.


## Advice to Aspiring Language Designers
If you want to design a language, I have some advice for how to do it. The first step is to
choose a model of computation that has not yet been well-explored. For example, I would
not design a language based on lambda calculus because that space has already been perfected
by Lisp and Haskell, and I would not design a langauge based on predicate logic because
Prolog already does a good job there. I would choose a model that has good properties (can
be executed quickly on hardware) and has not been explored by any other language. Right
now I think the field of Linear Logic doesn't have its own industry-strength programming
language. If you think you can design such a language, I would encourage you on.


## Summary
In short, a programming language is nothing but an implentation of a model of computation.

I have come up with a method to design well-loved languages

How to Create an Excellent Programming Lanugage



Many people mock Javascript for being bad. Go on any programming forum and you will find countless jokes at the expense of Javascript, but I argue that many of the things people hate most about Javascript were necessary for it to survive.
Why is Javascript perceived as bad?
To see why this is the case let us first look at the most maligned aspects of Javascript. When I ask people why they hate Javascript, they will say something along the lines of 
weak typing


# general weirdness
I find many of the criticisms of javascript are "why doesn't this language stop me from shooting myself in the foot". These are certainly desirable traits, and they are certainly being remedied in modern times with strict mode in ES6 and typescript. 
The History of Javascript 
Looking at the history of Javascript reveals why it must have been this way. It was invented by Brendan Eich in 10 days in 1995, when the web was nothing like it is today.  Just imagine how different the web is by looking at a website from 1995 and comparing it to any modern website. Eich, and indeed nobody, could have imagined how the web could have evolved, so planning for the web to change drastically was needed.

# Opinionated vs Flexible
The core of my argument is that people want Javascript to be opinionated and strict, when, due to the complex and evolving nature of the web, it is necessary that javascript be flexible and weak. Let's say Javascript took a hard stand and became inflexible on an issue pertaining to the 90s. We today would find that anachronistic and annoying. No central authority can predict how a programming language can be used, so it's better to leave all tools available to the programmer instead of walling off some features for fear that they might be mishandled. 


People malign javascript for all the wrong reasons