8 ms·
I long for a language which has a basic featureset, and then "freezes", and no longer adds any more language features. You may continue working on the standard
by londons_explore 7y ago
I long for a language which has a basic featureset, and then "freezes", and no longer adds any more language features.
You may continue working on the standard library, optimizing, etc. Just no new language features.
In my opinion, someone should be able to learn all of a language in a few days, including every corner case and oddity, and then understand any code.
If new language features get added over time, eventually you get to the case where there are obscure features everyone has to look up every time they use them.
- plopz 7y agoIsn't that what C is?
- FPGAhacker 7y agoCertainly Common Lisp.
- hu3 7y agoFrom what I've seen, Go is the closest we have for mainstream language resistant to change.
- zubspace 7y agoRecently the Go team decided not to add the try-keyword to the language. I'm not a Go programmer and was a bit stumped by the decision until I saw a talk of Rob Pike regarding the fundamental principle of Go to stick to simplicity first. [1] One of the takeaways is, that most languages and their features converge to a point, where each language contains all the features of the other languages. C++, Java and C# are primary examples. At the same time complexity increases. Go is different, because of the simplicity first rule. It easens the burden on the programmer and on the maintainer. I think python would definitely profit from such a mindset. [1] https://www.youtube.com/watch?v=rFejpH_tAHM https://www.youtube.com/watch?v=rFejpH_tAHM
- nerdponx 7y agosomeone should be able to learn all of a language in a few days, including every corner case and oddity, and then understand any code. Why should this be true for every language? Certainly we should have languages like this. But not every language needs to be like this.
- esfandia 7y agoWell, maybe not for every language, but probably for a language where simplicity has been a major feature.
- pmontra 7y agoI started using Python seriously only three years ago after 30 years of other languages and I didn't find it very simple. Maybe the core of the language is simple but the standard library and many other important modules can be very complicated. Among similar languages Ruby and JavaScript are far simpler.
- londons_explore 7y agoJavaScript used to be simple... But Promises, closures, prototype chains, and npm/modules/minification/webpack has added a massive amount of complexity to being able to just read and understand a bit of code.
- goatlover 7y agoJavascript isn't simple any longer. And I'm not sure Ruby is that simple, not once you dig into the advanced features.
- arkaic 7y agoVerrrrrrry few languages in common use are like this.
- Areading314 7y agoAbsolutely agree. How many times have you heard "that was true until Python 3.4 but now is no longer an issue" or "that expression is illegal for all Pythons below 3.3", and so on. Not to mention the (ongoing) Python 2->3 debacle.
- TomBombadildoze 7y ago> Not to mention the (ongoing) Python 2->3 debacle. When will this talking point die? It's not "ongoing". There's an overwhelming majority who have adopted Python 3 and a small population of laggards.
- Redoubts 7y ago> There's an overwhelming majority who have adopted Python 3 and a small population of laggards. That small population includes every BigCo with a large python codebase.
- orf 7y agoWho cares about syntax that doesn’t work in old, dead versions of Python 3? 3.5 and above is all that matters.
- markrages 7y agoPython 2.7 is not far from that language.
- tomkat0789 7y agoWhat's stopping people from forking the language at python 2.7? Let the pythonistas add whatever feature they feel like while people who need stability use "Fortran python" or whatever.
- mixmastamyk 7y agohttps://github.com/naftaliharris/tauthon https://github.com/naftaliharris/tauthon
- newen 7y agoI truly wish this would become a thing. It's really frustrating having to update my installed packages and my code for some stupid change the language designers thought is sooo worth it. Just stabilize the bloody thing so I can do some work. Updating code so it meshes with the "latest and greatest" is _not real work_.
- orf 7y agoFixing the entirely broken string/bytes mess up in Python 2 was worth it by itself. For bonus points old style classes went away, and the language got a significant speed boost. And now it’s not going to die a slow death, choking on the past poor decisions it’s burdened with. Trivializing that by suggesting it was some offhand, unneeded solution to a problem that some dreamy “language designer” thought up is at best completely and utterly ignorant. Also maintenance, in all forms, is work. That does involve updating your systems from time to time.
- newen 7y agoMaybe it's work if you get paid by lines of code and JIRA tickets but programming is just a tool for me to my real work done. So I would like to spend as little time programming as I possibly can.
- baq 7y agoremember the gang of four book? such books happen when the language is incapable of expressing ideas concisely. complexity gets pushed to libraries which you have to understand anyway. i'd rather have syntax for the visitor pattern or whatever else is there.
- poiuyt098 7y agoBrainfuck has been extremely stable. You can learn every operator in minutes.
- orwin 7y agoTry C maybe? It is still updated, but only really minor tweaks for optimisation. Also Common lisp specs never changed since the 90s and is still usefull as a "quick and dirty" language, with few basic knowledge required. But the "basic feature set" can make everything, so the "understand any code" is not really respected. Maybe Clojure is easier to understand (and also has a more limited base feature set, with no CLOS).
- kazinator 7y agoC compilers like GCC and Clang have dialect selection options that work; if you pick -std=c90, you can write C like it's 1990.
- mbo 7y agoElixir? From the v1.9 release just a few weeks ago: https://elixir-lang.org/blog/2019/06/24/elixir-v1-9-0-released/ https://elixir-lang.org/blog/2019/06/24/elixir-v1-9-0-releas... > As mentioned earlier, releases was the last planned feature for Elixir. We don’t have any major user-facing feature in the works nor planned. I know for certain some will consider this fact the most excing part of this announcement! > Of course, it does not mean that v1.9 is the last Elixir version. We will continue shipping new releases every 6 months with enhancements, bug fixes and improvements.
- scribu 7y agoInteresting! I imagine churn will still happen, except it will be in the library/framework ecosystem around the language (think JavaScript fatigue).
- _asummers 7y agoMost Elixir projects have very few dependencies because the Elixir and Erlang stdlibs are very batteries included. You don't typically reach for a dependency unless you need most of its features. Often you will reimplement the parts you need in your own code, except where it's reasonably complicated (pooling, DB connections, ORMs, web frameworks) or tricky to get right (security, password hashing, paxos).
- elgenie 7y agoThat's just an announcement that they reached the end of the list of user-facing syntax changes on their roadmap.
- vindarel 7y agoCommon Lisp seems to tick the boxes. The syntax is stable and it doesn't change. New syntax can be added through extensions (pattern matching, string interpolation, etc). The language is stable, meaning code written in pure CL still runs 20 years later. Then there are de-facto standard libraries (bordeaux-threads, lparallel,…) and other libraries. Implementations continue to be optimized (SBCL, CCL) and to develop core features (package-local-nicknames) and new implementations arise (Clasp, CL on LLVM, notably for bioinformatics). It's been rough at the beginning but a joy so far. https://github.com/CodyReichert/awesome-cl https://github.com/CodyReichert/awesome-cl
- nine_k 7y agoThe "very compact, never changing" language will end up not quite expressive, thus prone to boilerplate; look at Go. Lisps avoid this by building abstractions from the same material as the language itself. Basically no other language family has this property, though JavaScript and Kotlin, via different mechanisms, achieve something similar.
- agumonkey 7y agoI like to think that lisp is its own fixed point.
- colechristensen 7y agoThis is why a lot of scientific code still uses fortran, code written several decades ago still compiles and has the same output. How long has the code which was transitioned to python lasted?
- airstrike 7y ago> How long has the code which was transitioned to python lasted? A long time. 2to3 was good for ~90% of my code, at least
- colechristensen 7y agoGood for 90% of your code is not equivalent to getting precisely the same results from unmodified code written in the 80s.
- mixmastamyk 7y agoMore likely to mean 90% of projects, not 90% of each file, which would mean that every one was broken.
- hdfbdtbcdg 7y agoWe will review that statement in 30 years!
- yxhuvud 7y agoLikely, we will review that statement in 2038 at the latest.
- tjalfi 7y agoI have compiled Fortran programs from the 70s on modern platforms without changing a line. The compiler, OS, and CPU architecture had all disappeared but the programs still worked correctly.
- stefco_ 7y agoThis isn't that good of a metric for code utility. Sure, very-long-lived code probably solved the problem well (though it can also just be a first-mover kind of thing), but a lot of code is written to solve specific problems in a way that's not worth generalizing. I write a lot of python for astrophysics. It has plenty of shortcomings, and much of what's written will not be useful 10 years from now due to changing APIs, architectures, etc., but that's partly by design: most of the problems I work on really are not suited to a hyper-optimized domain-specific languages like FORTRAN. We're actively figuring out what works best in the space, and shortcomings of python be damned, it's reasonably expressive while being adequately stable. C/FORTRAN stability sounds fine and good until you want to solve a non-mathematical problem with your code or extend the old code in some non-trivial way. Humans haven't changed mathematical notations in centuries (since they've mostly proven efficient for their problem space), but even those don't always work well in adjacent math topics. The bra-ket notation of quantum mechanics, <a|b>, was a nice shorthand for representing quantum states and their linear products; Feynman diagrams are laughably simple pictograms of horrid integrals. I would say that those changes in notation reflected exciting developments that turned out to persist; so it is with programming languages, where notations/syntaxes that capture the problem space well become persistent features of future languages. Now, that doesn't mean you need to code in an "experimental" language, but if a new-ish problem hasn't been addressed well in more stable languages, you're probably better off going where the language/library devs are trying to address it. If you want your code to run in 40 years, use C/FORTRAN and write incremental improvements to fundamental algorithm implementations. If you want to solve problems right now that those langs are ill-suited to, though, then who cares how long the language specs (or your own code) last as long as they're stable enough to minimize breaking changes/maintenance? This applies to every non-ossified language: the hyper-long-term survival of the code is not the metric you should use (in most cases) when deciding how to write your code. My point is just that short code lifetimes can be perfectly fine; they can even be markers of extreme innovation. This applies to fast-changing stuff like Julia and Rust (which I don't use for work because they're changing too quickly, and maintenance burdens are hence too high). But some of their innovative features will stand the test of time, and I'll either end up using them in future versions of older languages, or I'll end up using the exciting new languages when they've matured a bit.
- fatbird 7y agoAll you're doing then is moving the evolution of the language into the common libraries, community conventions, and tooling. Think of JavaScript before ES2015: it had stayed almost unchanged for more than a decade, and as a result, knowing JavaScript meant knowing JS and jQuery, prototype, underscore, various promise libraries, AMD/commonjs/require based module systems, followed by an explosion of "transpiled to vanilla JS" languages like coffeescript. The same happened with C decades earlier: while the core language in K&R C was small and understandable, you really weren't coding C unless you had a pile of libraries and approaches and compiler-specific macros and such. Python, judged against JS, is almost sedate in its evolution. It would be nice if a combination of language, libraries, and coding orthodoxy remained stable for more than a few years, but that's just not the technology landscape in which we work. Thanks, Internet.
- elgenie 7y agoIt's apples and oranges. Python was explicitly designed and had a dedicated BDFL for the vast majority of its nearly 30 year history functioning as a standards body. JS, on the other hand, was hacked together in a week in the mid-90s and then the baseline implementation that could be relied on was emergent behavior at best, anarchy at worst for 15 years.
- fatbird 7y agoAgreed, but the anarchy of JS was a result of a dead standards process between the major vendors that resulted in de facto freeze. The anarchy is direct result of a stewardship body not evolving the language to meet evolving needs.
- orangecat 7y agoIn my opinion, someone should be able to learn all of a language in a few days, including every corner case and oddity, and then understand any code. "Understanding" what each individual line means is very different from understanding the code. There are always higher level concepts you need to recognize, and it's often better for languages to support those concepts directly rather than requiring developers to constantly reimplement them. Consider a Java class where you have to check dozens of lines of accessors and equals and hashCode to verify that it's an immutable value object, compared to "data class" in Kotlin or @dataclass in Python.
- toolslive 7y agoSometimes a language introduces a concept that's new to you. Then you need way more time. For example, monads : I understood it (the concept) rather quickly, but it took a few weeks to get it down so I could benefit from it.
- locoman88 7y agoFully agree. If we continue with this madness in five years Python will become indistinguishable from the Python I learnt 10 years ago. Seems the Golang people have much cooler heads. Time to push for Golang at my workplace
- linsomniac 7y agoI'm in operations and I've spent much of my career writing code for the Python that worked on the oldest LTS release in my fleet, and for a very long time that was Python 1.5... I was really happy, in some ways, when Python 2 was announced as getting no new releases and Python 3 wasn't ready, because it allowed a kind of unification of everyone on Python 2.7. Now we're back on the treadmill of chasing the latest and greatest. I was kind of annoyed when I found I couldn't run Black to format my code because it required a slightly newer Python than I had. But... f strings and walrus are kind of worth it.
- DonHopkins 7y agoThe Turing Machine programming language specification has been frozen for a long time, and it's easy to learn in a few days. So has John von Neumann's 29 state cellular automata! https://en.wikipedia.org/wiki/Von_Neumann_cellular_automaton https://en.wikipedia.org/wiki/Von_Neumann_cellular_automaton https://en.wikipedia.org/wiki/Von_Neumann_universal_constructor https://en.wikipedia.org/wiki/Von_Neumann_universal_construc... (Actually there was a non-standard extension developed in 1995 to make signal crossing and other things easier, but other than that, it's a pretty stable programming language.) >Renato Nobili and Umberto Pesavento published the first fully implemented self-reproducing cellular automaton in 1995, nearly fifty years after von Neumann's work. They used a 32-state cellular automaton instead of von Neumann's original 29-state specification, extending it to allow for easier signal-crossing, explicit memory function and a more compact design. They also published an implementation of a general constructor within the original 29-state CA but not one capable of complete replication - the configuration cannot duplicate its tape, nor can it trigger its offspring; the configuration can only construct.
- chewxy 7y agoGo? I moved a lot of my datascience and machine learning process to Go. Only thing really left in Python land is EDA
- alexhutcheson 7y agoLua is pretty close, and pretty close to Python in terms of style and strengths. Edit: I actually forgot about the split between LuaJIT (which hasn’t changed since Lua 5.1), and the PUC Lua implementation, which has continued to evolve. I was thinking of the LuaJIT version.
- owaislone 7y agoThat's what Go has been so far but it might see some changes soon after being "frozen" for ~10 years.
- mr_crankypants 7y agoSuch languages exist. Ones that come to mind offhand are: Standard ML, FORTH, Pascal, Prolog. All of which are ones that I once thought were quite enjoyable to work in, and still think are well worth taking some time to learn. But I submit that the fact that none of them have really stood the test of time is, at the very least, highly suggestive. Perhaps we don't yet know all there is to know about what kinds of programming language constructs provide the best tooling for writing clean, readable, maintainable code, and languages that want to try and remain relevant will have to change with the times. Even Fortran gets an update every 5-10 years. I also submit that, when you've got a multi-statement idiom that happens just all the time, there is value in pushing it into the language. That can actually be a bulwark against TMTOWTDI, because you've taken an idiom that everyone wants to put their own special spin on, or that they can occasionally goof up on, and turned it into something that the compiler can help you with. Java's try-with-resources is a great example of this, as are C#'s auto-properties. Both took a big swath of common bugs and virtually eliminated them from the codebases of people who were willing to adopt a new feature.
- zephyrfalcon 7y agoProlog has an ISO standard... I am not sure if it's still evolving, but specific Prolog implementations can and often do add their own non-standard extensions. For example, SWI-Prolog added dictionaries and a non-standard (but very useful) string type in version 7. That said, it is nice that I can take a Prolog text from the 1980s or 1990s and find that almost all of the code still works, with minor or no modifications...
- skarz 7y agoWish granted: https://en.m.wikipedia.org/wiki/Brainfuck https://en.m.wikipedia.org/wiki/Brainfuck
- jnwatson 7y agoThe only frozen languages are the ones nobody uses except for play or academic purposes. As soon as people start using a language, they see ways of improving it. It isn't unlike spoken languages. Go learn Esperanto if you want to learn something that doesn't change.
- BillChapman 7y agoEsperanto does change, in that new items of vocabulary are introduced from time to time. For example, 'mojosa', the word for 'cool' is only about thirty years old.
- dwaltrip 7y agoAll human languages change over time. It is the nature of language.
- diminoten 7y agoWhy can't you do this with Python? No one said you had to use any of these new features... Though to me that's like saying, "I want this river to stop flowing" or "I'd prefer if the seasons didn't change."
- coleifer 7y agoLua is a great small language.
- dingo_bat 7y agoYou're talking about C.