DEV Community

Adam Gordon Bell
Adam Gordon Bell

Posted on

What's gotten better in programming languages

I have a question, especially for those who’ve been programming for some time or have experience with older languages:

What improvements have you seen in programming languages that aren’t related to syntax or semantics of the language?

I’m thinking about things like the introduction of package managers for pulling in third party dependencies, and the existence of code formatters or linters.

I guess integrated testing into the tooling / language in rust and golang would count as well.

( Another way to frame this would be what do you miss when you are programming in c or c++ or some older language that isn’t the language, but more about the tooling and ecosystem.)

Discussion (7)

carlfish profile image
Charles Miller

Languages are generally becoming more "batteries included" with respect to wanting to get important ergonomic things right like build systems, testing, dependency management, even code formatting and linting, out of the box.

Type systems, if you want a statically typed language, are generally getting more expressive, increasing the number of times the type system helps you write correct code and decreasing the number of times it gets in the way for no good reason.

Even languages that aren't explicitly functional generally provide useful functional primitives, which in turn helps provide useful async primatives.

Compiler errors get better every year.

Many newer languages were built with intention, to solve specific problems people had with their predecessors.

codewander profile image

Also, I am excited about tools like gitpod for allowing one to instantly develop and review multiple branches in parallel, directly in the browser with vs code and pre fetched dependencies.

adamgordonbell profile image
Adam Gordon Bell Author

Oh yeah, I just started using a dev container and its super cool.
I haven't tried gitpod yet.

codewander profile image

Some people complain about the complexity of bazel, but advanced build systems within the bazel family look promising for working in teams on large codebases.

codewander profile image
codewander • Edited on

LSP has seemed to reduce the divisions between editors now that they share some core logic between the editors.

andrewbaisden profile image
Andrew Baisden

The tooling is much better we have powerful code editors and IDE's that have a ton of extensions that make coding more fun and easier. Back in the day many people were writing code in Notepad++ and Dreamweaver which was not very intuitive.

Those were hard times.

eljayadobe profile image

Programming languages are tools. Some are better suited than others for certain kinds of problem domains.

Over the last 5 decades, I've seen the rise of object oriented programming languages as an alternative to procedural programming languages, and then the rise (still rising) of functional programming languages as an alternative to the other two paradigms. And perhaps a renaissance of the very venerable programmer's programming languages — LISP, Scheme, Clojure, and friends.

I've seen newer programming languages with incredible expressivity and concise syntax.

I've seen the addition of (usually domain specific) declarative programming languages, such as XAML for WPF.

I've seen attempts at making domain specific languages easier to create and maintain, such as JetBrains MPS, or Justin Chase's meta#. And I do believe that in the next decades we'll see an explosion of DSL solutions for real applications and real world problems.

I've seen the evolution of C# to Spec# to Sing# to M# (for Midori, not the other M# which is totally different but same name). Then all of that cumulative awesomeness pitched in the dumpster. Alas.

I've seen the embedded scripting engine Lua spread like wildfire, because it hit the sweet spot of functionality and small footprint and extensibility.

I've seen the war for the interwebs being fought for domination by Flash, Java, and Silverlight to win the hearts and minds. And all three of those giants were toppled by JavaScript, the little engine that could. JavaScript, a language designed to embedded teeny-tiny snippets of event handling glue code to do relatively simple DOM manipulations in response to those events. Now it's being leveraged to create giant MLOC applications.

I've seen the ping-pong CPU technology going between CISC to nRISC (i.e., 6502) to CISC to RISC to CISC, and all the assembly language evolutions and revolutions (Alpha, SPARC, PowerPC). And the enormous computing power and potential of the GPU, which is still vastly underutilized by most programming languages.

I've seen the rise of virtual machines, such as JavaVM and .NET, and the vibrant ecosystems for those platforms and the many languages for those platforms.

I've seen the behemoth C++ grow and evolve in both great and puzzling ways, sometimes with seemingly haphazard and incoherent syntax and rules. Struggling for backwards compatibility, yet sometimes falling short, and in my opinion would be better for C++ to stop pretending to be C compatible and make a clean break of it.

In summary, a lot has gotten better. But as an industry, we're still in the stone age. We're making bespoke / haute couture software. We don't have standardized parts. We're not what I'd consider to be at the craft guild stage as an industry, let alone engineering stage. The future is bright, and there is still a lot to be done.