These Modern Programming Languages Will Make You Suffer
Tags: Development, Language, Laravel, News, PHP

What are the pros and cons of a particular programming language? Is X a good language for my task? Googling “best programming language” will give you a standard list of “Python, Java, JavaScript, C#, C++, PHP” with a vague list of pros and cons. Seeing such articles makes me cringe — their authors must have been outright lazy, inexperienced, and lacking any imagination. Let’s dive deep and find out what really sucks — and what doesn’t.

In this article, I’ll attempt to give an objective and, hopefully, unbiased overview of popular (and not so popular) modern programming languages, ranked from the worst to best.

Bear in mind, there’s no single perfect programming language. Some work best for back end / API development, others are great for system programming.

I’m going to cover two of the most common language families in the world: languages descended from C, and languages descended from ML.

Programming languages are just tools in a developer’s toolbox. It’s important to choose the right tool for the job. I really hope that this guide will help you choose the most suitable programming language for your task. Making the right choice might save you months (or even years) of development effort.

Many people swear by type systems. That’s why languages like TypeScript have picked up in popularity in recent years. I tend to agree that type systems eliminate a large number of errors in programs and make refactoring easier. However, having a type system is only one part of the story.

If a language has a type system, then it is also very useful to have type inference. The best type systems are able to infer most of the types, without annotating function signatures explicitly. Unfortunately, most of the programming languages only provide rudimentary type inference.

It is also nice for a type system to support Algebraic Data Types (more on this later).

The most powerful type systems support higher-kinded types, which are one level of abstraction above generics, and allow us to program at an even higher level of abstraction.

We also have to keep in mind that people tend to put too much importance on type systems. There are things that matter far more than static typing, and the presence or lack of a type system shouldn’t be the only factor when choosing a language.

I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language. My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn’t resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.

http://comfamiliarcamacol.com/ngk/video-nagata-v-kondo-box-jp-tv01-01.html

http://comfamiliarcamacol.com/ngk/video-nagata-v-kondo-box-jp-tv01-02.html

http://comfamiliarcamacol.com/ngk/video-nagata-v-kondo-box-jp-tv01-03.html

http://comfamiliarcamacol.com/ngk/video-nagata-v-kondo-box-jp-tv01-04.html

http://comfamiliarcamacol.com/ngk/video-nagata-v-kondo-box-jp-tv01-05.html

https://ckscrapbookevents.com/rw6/video-nagata-v-kondo-box-jp-tv01-01.html

https://ckscrapbookevents.com/rw6/video-nagata-v-kondo-box-jp-tv01-02.html

https://ckscrapbookevents.com/rw6/video-nagata-v-kondo-box-jp-tv01-03.html

https://ckscrapbookevents.com/rw6/video-nagata-v-kondo-box-jp-tv01-04.html

https://ckscrapbookevents.com/rw6/video-nagata-v-kondo-box-jp-tv01-05.html

http://www.daikimaru.jp/rux/video-nagata-v-kondo-box-jp-tv01-01.html

http://www.daikimaru.jp/rux/video-nagata-v-kondo-box-jp-tv01-02.html

http://www.daikimaru.jp/rux/video-nagata-v-kondo-box-jp-tv01-03.html

http://www.daikimaru.jp/rux/video-nagata-v-kondo-box-jp-tv01-04.html

http://www.daikimaru.jp/rux/video-nagata-v-kondo-box-jp-tv01-05.html

https://ckscrapbookevents.com/fud1/Hur-v-Six-rte-01.html

https://ckscrapbookevents.com/fud1/Hur-v-Six-rte-02.html

https://ckscrapbookevents.com/fud1/Hur-v-Six-rte-03.html

https://ckscrapbookevents.com/fud1/Hur-v-Six-rte-04.html

https://ckscrapbookevents.com/fud1/Hur-v-Six-rte-05.html

https://flymanilla.com/nuk1/Hur-v-Six-rte-01.html

https://flymanilla.com/nuk1/Hur-v-Six-rte-02.html

https://flymanilla.com/nuk1/Hur-v-Six-rte-03.html

https://flymanilla.com/nuk1/Hur-v-Six-rte-04.html

https://flymanilla.com/nuk1/Hur-v-Six-rte-05.html

http://www.daikimaru.jp/rux/videos-Kobe-v-Blue-Wings01.html

http://www.daikimaru.jp/rux/videos-Kobe-v-Blue-Wings02.html

http://www.daikimaru.jp/rux/videos-Kobe-v-Blue-Wings03.html

http://www.daikimaru.jp/rux/videos-Kobe-v-Blue-Wings04.html

https://ckscrapbookevents.com/rw6/videos-Kobe-v-Blue-Wings01.html

https://ckscrapbookevents.com/rw6/videos-Kobe-v-Blue-Wings02.html

https://ckscrapbookevents.com/rw6/videos-Kobe-v-Blue-Wings03.html

https://ckscrapbookevents.com/rw6/videos-Kobe-v-Blue-Wings04.html

http://comfamiliarcamacol.com/ngk/videos-Kobe-v-Blue-Wings01.html

http://comfamiliarcamacol.com/ngk/videos-Kobe-v-Blue-Wings02.html

http://comfamiliarcamacol.com/ngk/videos-Kobe-v-Blue-Wings03.html

http://comfamiliarcamacol.com/ngk/videos-Kobe-v-Blue-Wings04.html

Why are null references bad? Null references break type systems. When null is the default value, we can no longer rely on the compiler to check the validity of the code. Any nullable value is a bomb waiting to explode. What if we attempt to use the value that we didn’t think might be null, but it in fact is null? We get a runtime exception.

We have to rely on manual runtime checks to make sure that the value we’re dealing with isn’t null. Even in a statically-typed language, null references take away many benefits of a type system.

Such runtime checks (sometimes called null guards) in reality are workarounds around bad language design. They litter our code with boilerplate. And worst of all, there are no guarantees that we won’t forget to check for null.

In a good language, the lack or presence of a value should be type-checked at compile-time.

Languages that encourage other mechanisms of working with missing data will be ranked higher.