3 ms·
Thing is, except for CS theory evolving, the programming language environment from 30 years ago is in my opinion irrelevant from a maturity perspective. The num
by oblio 9y ago
Thing is, except for CS theory evolving, the programming language environment from 30 years ago is in my opinion irrelevant from a maturity perspective. The number of practitioners was probably 1 million or so worldwide, now there’s probably 20-40+ million programmers worldwide. We didn’t have widespread internet access, barely a handful of Open Source communities, compilers were generally commercial and extremely expensive, companies behind technologies were extremely volatile, etc.
While that made for very nice war stories, it also meant that you’d have the “ship” sinking under you completely. Now a tech still stays around to some degree.
A C developer from 1990 could still be a C dev in 2018. A Java dev from 1998 could still be a C dev in 2018. And a programmer in your average mainstream language in 2018 could reasonably expect to be working in the same language in 2018. Especially if that language has enterprise traction (Cobol, Java, C#, Javascript, SQL, etc.).
Also, languages are a lot more similar to each other than they used to be, in terms of expressiveness and power. Lisp was a “lightsaber” to the “stones” of the 80’s, now it’s at most a slightly more powerful “machine-gun”, at best.
And regarding language evolution itself, everything evolves. Or did Common Lisp programmers generally write unit tests, have integration test harnesses, use package repos, etc. back in 1995? I somehow doubt that :)
- drmeister 9y agoCommon Lisp has: generic functions, homo-iconic macros written in Common Lisp, reflection, multiple dispatch, closures, optional typing, correct implementation of lexical scope, dynamically scoped variables, a metaobject protocol, conditions & restarts, and a compiler that is available for customization. One or a few of these have made it into other languages in some form or another - but not all together. Common Lisp also has an excellent package manager (quicklisp/ASDF) a programmers IDE (emacs/slime vim/vlime), interoperation with C libraries (CFFI) and lots and lots of libraries that don't need to be constantly updated to keep them working because the underlying language changes. I wouldn't call it just a slightly more powerful weapon. Just the macros - my goodness - in Common Lisp you can write programs that write programs! It's easy and organic and elegant because they are written in the same language as everything else. Macros let you write code that customizes itself and optimizes itself at compile time for specific use cases. You can escape the drudgery of writing similar code over and over again. You kind of need s-expression syntax for macros to be easy to write - so no other language with complex syntax will ever have them like Common Lisp does. Languages are all Turing complete - we can do everything in every language - but for the kind of hard problems that I want to solve, only Common Lisp has helped me out of the Turing tarpit. Also, C++ is a great domain specific language for creating tables of cache friendly compact data structures and it has great compilers.
- flavio81 9y ago>Just the macros - my goodness - in Common Lisp you can write programs that write programs!! ... and at runtime OR compile-time (your choice!) ... and by using plain, simple Common Lisp; no special, cumbersome AST-transformation libraries needed!
- oblio 9y agoAt least optional typing and macros are not considered to be universal benefits for programming. Having a ton of features has been proven in many occasions to be counterproductive. Paradox of choice, higher learning curve, etc.
- flavio81 9y ago>At least optional typing and macros are not considered to be universal benefits for programming. That's just your opinion. >Having a ton of features has been proven in many occasions to be counterproductive. Paradox of choice, higher learning curve, etc. Ok, let's see you need to get the numerical value of several big integrals. You have two choices: a. Pen and paper plus calculator. b. Computer with sophisticated computer algebra system Learning curve in (b) is way higher. Alternative (b) is also way more productive. Helicopters have also a steeper learning curve than cars. >At least optional typing and macros are not considered to be universal benefits for programming. So perhaps you don't know the benefits. Lisp Metaprogramming benefits become obvious after taking the time to learn them. Optional typing dramatically increases execution speed, something that is very relevant and important in 2018.
- oblio 9y agoYou seem to be a bit too... enthusiastic about this conversation, for my tastes :) I won't go into everything cause it would take way too much time, but I have to point one thing out: > Optional typing dramatically increases execution speed, something that is very relevant and important in 2018. As compared to what? I'm guessing your assumption was that I was thinking about purely dynamic languages? Not really, I was thinking about using static languages with type inference.
- deleted 9y ago[deleted]
- flavio81 9y ago>Also, languages are a lot more similar to each other than they used to be, in terms of expressiveness and power. Lisp was a “lightsaber” to the “stones” of the 80’s, now it’s at most a slightly more powerful “machine-gun”, at best. Please elaborate more and explain.
- oblio 9y agoHow many features coming from Lisp, ML, Haskell and academic languages have made it into mainstream languages now? Many. How many were in mainstream languages in the 80’s? A few. Memory management, generics, etc.
- flavio81 9y agoAllright, let's take some list of what can be understood for "mainstream" languages (because, according to other criteria, Lisp is mainstream too.) TIOBE index top 10: Java, C, C++, Python, C#, Visual Basic.NET, PHP, Javascript, SQL, Ruby. let's compare to Lisp and Haskell: - NONE of those langs have the hindley-milner type system, type inference and typeclasses of Haskell. - even Common Lisp's type system is more sophisticated than almost all langs on the list, allowing for union types. - all of those langs only allow you to write the code that will execute at runtime. CL allows you to specify if a function is to be executed at read time, compile time, and run time. - NONE has an object oriented system with multiple dispatch nor a meta-object system. Unlike Common Lisp. - None have metaprogramming based on homoiconicity (like Common Lisp), so the only way of macros is to use a cumbersome AST->AST library, and even then, it can only be done at compile time nor runtime. - Only a very few allow changing the definiton of a class or function at runtime, without stopping the running program, and then it's often a difficult proposition because the language wasn't designed to do this on the first place. Unlike in Common Lisp. - For the garbage collected languages there, NONE allows you to circumvent or disable the garbage collector, unlike CL. - For the garbage collected languages there, NONE is faster than CL, and only CL allows the programmer to write Lisp code that reaches C speed, if he/she wishes so. - only a few have built-in support for all of these: integers, arbitrary precision numbers, rationals, floats with IEEE compliance, complex numbers, and bit vectors. All which CL brings you by default. Now, you can suggest more languages and I can go on. There are very few languages that can compete with Coq, Agda, Haskell, Ada/Spark, Common Lisp, Julia and Racket today. No, there are many features missing. Features that are very relevant. Do you know that many of the design patterns often used in Java are unnecessary in Common Lisp simply because many of them are workarounds for things that the Java OOP system lacks but Lisp's OOP system implements?
- jimbokun 9y ago"And a programmer in your average mainstream language in 2018 could reasonably expect to be working in the same language in 2018." Pretty radical claim there, are you sure about that? :)
- oblio 9y agoIt’s simple math, really. Let’s say we had 1 million programmers in the 80’s, writing enteprise software costing 1m * 8h * 365d * 10y = too lazy to do the math, let’s say 30 billion dollars. A lot of that software died with the companies using it, so maybe 10 billions’ worth survived, needing today N C programmers, P Cobol programmers, etc. for maintenance. How do you think the numbers and the timespans look from a time when we have 20-40+ million programmers, working with better tools on system which are even more tightly coupled with core business functions? Java will outlive both Cobol and cockroaches :p
- drmeister 9y agoI didn't want to call out an obvious typo - but then I thought "maybe they are talking about Javascript frameworks" and then I thought "yeah - one can always hope". :-)
- pfdietz 9y ago"Or did Common Lisp programmers generally write unit tests, have integration test harnesses, use package repos, etc. back in 1995? I somehow doubt that :)" Richard Waters wrote and made available a nice pair of utilities that I've long used. http://www.cs.cmu.edu/Groups/AI/util/lang/lisp/code/testing/rt/0.html http://www.cs.cmu.edu/Groups/AI/util/lang/lisp/code/testing/... http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/code/testing/cover/0.html http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/l... The first is the RT package, which allows definition and execution of unit tests. Many elaborations of this have been written over the years. The second, COVER, is more impressive: it uses Common Lisp macrology to implement a code coverage tool. Combined with RT you can not only unit test your code, you can confirm the level of branch coverage your unit tests achieve. (I've since hacked up COVER to enable various extensions, including saving of coverage information for aggregation from different executions, and rollback to enable automated search for minimal coverage-improving inputs. Not available publicly right now, unfortunately.)
- lispm 9y ago> use package repos ...? If one used a Lisp system at MIT in the 80s, probably. The typical Lisp Machine at MIT was networked and shared file servers (also from other types of machines). When one uses a Lisp Machine on the network, one uses a name server (not DNS or NIS, which did not exist at that time) which define one or more sites. The site information in the name server provides information about machines, services, users, printers etc. In the 80s the MIT network was already vast with hundreds of machines. It was basically similar to what Unix system did with mounted NFS volumes, but here built into the Lisp system. This was before TCP/IP, when Lisp Machines used the CHAOS protocol for networking. Now when one wanted to load some software into a Lisp Machine, one uses a command like 'Load System FOO', where FOO is the name of the system. The Lisp Machine shares with other machines a central registry for system names, which then point to a location in the file system. So this would find the system definition, load it and then load the system components. One could also ask it to load a specific version or load a specific patch level - or just the newest version. A system could also have other files like documentation, C files, etc.. There was also a way to write those to tape or an archive format and transfer it that way. Thus that was a networked repository for libraries and applications. Some of those libraries were shared across different machine types and Lisp dialects. For example the LOOP feature was a library sharing source code with Maclisp, Zetalisp, NIL, etc. So you could load this from a central location into different Lisp systems - not just Lisp Machines.