38 ms·

Six programming languages I’d like to see

• xputer 4y ago
  I would like to see a proper language with built in support for Unix Shell commands. Similar to bash or perl with a use Shell import, but without the limitations of bash or the craziness of perl. I really like the idea of zx, but still doesn't look clean enough to me.
  • Kinrany 4y ago
    Have you seen oilshell.org?
• thesuperbigfrog 4y ago
  >> A serious take on a contract-based language Ada has design-by-contract as part of the language: https://learn.adacore.com/courses/intro-to-ada/chapters/contracts.html https://learn.adacore.com/courses/intro-to-ada/chapters/cont... Since Ada is used for safety-critical systems programming you could argue that it is very serious about it. >> And tool integration! One of the coolest things Eiffel sorta did was use contracts to infer tests. If you have contracts, you can use a fuzzer to get integration tests for free. How about tools that extend design-by-contract to formal verification? https://learn.adacore.com/courses/intro-to-spark/chapters/01_Overview.html# https://learn.adacore.com/courses/intro-to-spark/chapters/01... SPARK is limited to a subset of Ada, so it is not without limitations, but it can be very useful depending on what you are trying to do.
  • ainar-g 4y ago
    The D programming language, too. https://dlang.org/spec/function#contracts https://dlang.org/spec/function#contracts
    • bvoq 4y ago
      +1 on D. It even has contracts for members.
  • DoingIsLearning 4y ago
    If Adacore had published a full featured free compiler for students/universities by the time Ada 95 standard was published, I am sure that Ada could have occupied the space C++ takes today. Mostly what Ada lacks is not the features but the comunity effect, we saw that when comparing feature parity with C++ and we see that again when comparing feature parity with Rust. There are a lot of briliant features and tooling in Ada, but unless there is a community effect (or a gigantic industry sponsor e.g. golang) it is difficult to convince people to switch over. I can't remember who said it so I will paraphrase, the best language/target to program in is whatever your friends/colleagues are using.
    • thesuperbigfrog 4y ago
      >> If Adacore had published a full featured free compiler for students/universities by the time Ada 95 standard was published, I am sure that Ada could have occupied the space C++ takes today. Agreed. If there had been more free (gratis) or low-cost Ada compilers at that time Ada would be far less niche than it is today. There is increased interest in Ada today thanks to Rust. There is also interplay between Rust and Ada/SPARK features with Rust getting some Ada features and SPARK getting some Rust features. Ferrous Systems is working with AdaCore on the Ferrocene Language Specification to formally document the Rust subset that Ferrocene will use: https://ferrous-systems.com/ferrocene/ https://ferrous-systems.com/ferrocene/ https://ferrous-systems.com/blog/ferrocene-language-specification/ https://ferrous-systems.com/blog/ferrocene-language-specific... It is exciting to see Rust mature so it can one day be used in safety-critical work.
      • the_only_law 4y ago
        This seems to be a common theme among certain languages, software, etc. from the 90s. I've heard similar things about Smalltalk.
        • igouy 4y ago
          Long before the digital era that common theme would have been expressed as — Don't look a gift horse in the mouth.
  • hwayne 4y ago
    Forgetting about SPARK was a big whoops for me. (Lots of formal verification languages are based on contracts, like SPARK, Frama-C, and Dafny. I'm interested in uses for contracts that aren't just formal verification, though!)
    • thesuperbigfrog 4y ago
      >> I'm interested in uses for contracts that aren't just formal verification, though! Ada 2012 design-by-contract features aren't just for formal verification, they can be used in a general purpose way similar to Eiffel: https://learn.adacore.com/courses/intro-to-ada/chapters/contracts.html https://learn.adacore.com/courses/intro-to-ada/chapters/cont... Can you elaborate a bit more about the wanted features for a language with semantic relations?
      • hwayne 4y ago
        An example off the top of my head would be writing a serializer/deserializer pair and explicitly saying they are inverses of each other, as opposed to having to implicitly say that in a round-trip property test. Another idea would be being able to say that two data representations are isomorphic under a given transformation, so I can define a function for one transformation and call it on the other. I don't know how useful this would be in practice, but it seems interesting to me!
        • thesuperbigfrog 4y ago
          >> writing a serializer/deserializer pair and explicitly saying they are inverses of each other, as opposed to having to implicitly say that in a round-trip property test. That capability would be very useful. There are many cases where I have had to define serialization and deserialization functions for numerous objects and had to create so much "boilerplate" unit test code like you describe. It made me wish I was using a Lisp with built-in reader and printer functions. >> being able to say that two data representations are isomorphic under a given transformation, so I can define a function for one transformation and call it on the other. This strikes me as very Haskell-ish, but could be quite useful to ensure certain properties or invariants.
  • ajdude 4y ago
    When I read "contract-based language"I immediately thought of Ada. I could be wrong but I think SPARK is incorporated into the Ada 2022 standard at this point, it could really be thought of as part of the language. It's the furthest thing from a "dynamically typed language" but it can probably also check the "math" requirement here too.
  • ibains 4y ago
    Its not public language, but at Risk Management Systems, I worked on Contract Definition Language- an external DSL for computable insurance, re-insurance contracts. This was used to simulate insurance losses when catastrophic events happen (earthquake, hurricane)
    • fernirello 4y ago
      Any good reference for that CDL? The idea seems quite useful for what I'm working on. All I found is a wishy-washy doc with poorly chosen examples [0] [0] https://www.riskdataos.org/html/HelpCenter/Content/CDL/CDL_Semantics_Intro.htm https://www.riskdataos.org/html/HelpCenter/Content/CDL/CDL_S...
      • occamrazor 4y ago
        RMS never played nice on interoperability. I wouldn’t bet on the CDL to become a useful standard, because it is under-powered, under-specified and stagnant. The “open” alternative is OASIS. Their Open Exposure Data standard [1] is complete and supported by many industry participants. Unfortunately it’s a database based format, rather than a text based DSL, but still betterthan the alternatives. [1] https://github.com/OasisLMF/OpenDataStandards/tree/master/OpenExposureData/Docs https://github.com/OasisLMF/OpenDataStandards/tree/master/Op...
        • fernirello 4y ago
          Thank you! I wasn't aware of OASIS. Reading up now.
  • kaba0 4y ago
    Java has a similar “extension” as well: https://en.m.wikipedia.org/wiki/Java_Modeling_Language https://en.m.wikipedia.org/wiki/Java_Modeling_Language
  • dude12344 4y ago
    Also Nim has contracts and supports formal proofing: https://nim-lang.org/docs/drnim.html https://nim-lang.org/docs/drnim.html
    • elcritch 4y ago
      A more practical one might be this contracts library https://github.com/Udiknedormin/NimContracts https://github.com/Udiknedormin/NimContracts
  • hinkley 4y ago
    Better still would be to take progressively typed languages, combined with contracts and property-based testing, and iterate toward a more precise contract for all of your code whenever it became necessary or whenever you got bored. What are the consequences of deciding that no Foo's are allowed to be red? Hmm, that's interesting/unintended... The main difficulties with statically typed languages seem to be both 1) quickly arriving at a workable prototype, and 2) dealing with the consequences of regrettable decisions made early on. Those two being in tension contributes a lot of drama, and not just in analysis paralysis.
  • tonyhb 4y ago
    Similarly, Ruby had RDL - which implemented pre/post contracts and type checking prior to Sorbet. It was actually pretty nice, if slow. https://github.com/tupl-tufts/rdl https://github.com/tupl-tufts/rdl
  • miclill 4y ago
    Fuzion has contracts as well: https://flang.dev/tutorial/pre_post_conditions https://flang.dev/tutorial/pre_post_conditions https://github.com/tokiwa-software/fuzion https://github.com/tokiwa-software/fuzion Disclaimer, I work in the Fuzion team.
• onychomys 4y ago
  > When I’m trying out lots of different equations, keystokes matter a lot. That's a pretty weird way to do math, honestly. Shouldn't you figure out what equation you need and then just type it? If you're off by one or whatever, adjust it then, you're still only typing it twice.
• eatonphil 4y ago
  input = 1 out1: input + 1 #out1 is now 2 input = 4 #out1 is now 5 out2: out1.replace(+, -) #out2 is now 3 # let's pull an APL input = 4 2 #out1 is 5 3 #out2 is 3 1 The reactive programming idea a la Excel but text-based looks really neat. I'd love to play around with that kind of thing.
  • arethuza 4y ago
    I have a vague recollection that the language used by MS PowerApps might work like that: https://docs.microsoft.com/en-us/power-platform/power-fx/overview https://docs.microsoft.com/en-us/power-platform/power-fx/ove...
  • shreyshnaccount 4y ago
    doesn't interactive Julia (that's what it's called?) do this? i remember seeing an example but i might be misremembering things
    • francogt 4y ago
      Pluto.jl[1] works like this. It’s a reactive notebook. It’s a really neat project. [1]https://github.com/fonsp/Pluto.jl https://github.com/fonsp/Pluto.jl
      • shreyshnaccount 4y ago
        Ah yes, that's what I was thinking about. thanks! its so cool xD
    • sdfhdhjdw3 4y ago
      Yes. And Julia also does the "optimized version of...". It dispatches on types.
  • kej 4y ago
    I haven't used it beyond playing with the tutorial, so I don't know how well it works in practice, but Svelte does this with JavaScript: https://svelte.dev/tutorial/reactive-declarations https://svelte.dev/tutorial/reactive-declarations
• pointlessone 4y ago
  > A language designed around having first-class GUI support Delphi and friends[1] is still out there. There's also Lazarus[2] if you don't want to fork off a few grands. [1] https://www.embarcadero.com/products https://www.embarcadero.com/products [2] https://www.lazarus-ide.org/ https://www.lazarus-ide.org/
  • zabzonk 4y ago
    Difference between language and IDE.
    • andsoitis 4y ago
      Delphi (and freepascal) have good support in the language for visual components.
      • zabzonk 4y ago
        In the library, not so much in the Pascal implementation, though the Pascal does support the library very well.
  • yagodragon 4y ago
    I'd say Dart[0] fits the description. [0]https://dart.dev/ https://dart.dev/
    • eli_gottlieb 4y ago
      That's just for web apps.
      • bmitc 4y ago
        Flutter can be used for both mobile and desktop apps, although mobile is definitely the primary focus. In my view, Flutter basically equals Dart. I don't know what else people use Dart for.
• poulpy123 4y ago
  > A better calculator language Well there are many of them like MATLAB, IDL, scilab, R and others. Python is verbose because it's not a calculator language but a general purpose language. I find J unreadable.
  • mjb 4y ago
    R is my go-to for this, and one I recommend often. It makes a nice calculator language (with only a little weird syntax), has a very rich standard library of functions, and is reasonably fast. The great thing about R is that it scales well with task difficulty. It works well for a couple numbers. Then you can use data frames, and the Tidyverse (https://www.tidyverse.org/ https://www.tidyverse.org/) packages to do a lot of data analysis (especially dplyr, which is extremely powerful). Finally, if you want to look at your data, the built-in plotting capabilities are solid, and ggplot2 is both extremely powerful and reasonably easy to use.
  • O5vYtytb 4y ago
    Indeed, the example: > import math prod([math.factorial(x) for x in l]) No! Bad python! In J it’s just / ! l, quite literally an order of magnitude fewer keystrokes. I don't know anything about `match.factorial()` or `prod()` but I can deduce what it's doing. `/ ! l` is nonsense.
    • hwayne 4y ago
      I don't need you to be able to deduce what the J is doing. What I need is to write the computation as fast as possible so I can get the answer I need to know and then get back to whatever else I was doing. If I was writing something I needed to share with someone else, for sure I wouldn't use J!
    • rak1507 4y ago
      match? definitive proof that verbosity introduces bugs ;) (also you can't deduce what ! means? it's literally the factorial symbol)
• fjfaase 4y ago
  If you mean with a Graph language, a complex data structure language, you might have a look at https://github.com/FransFaase/DataLang https://github.com/FransFaase/DataLang which gives some ideas about modelling complex data structures and where I talk about the different kind of reference that you might want in such a language.
• jgtrosh 4y ago
  > keystokes matter a lot Meta
• nika1975 4y ago
  Dart is a language optimized for use in the Flutter GUI framework. Well done.
• mjb 4y ago
  The language I want is a specification language (a bit like Pluscal or P) which allows me to specify distributed system behavior, then ask both correctness (liveness/safety) questions and quantitative behavior questions. I wrote a bit about it here: https://brooker.co.za/blog/2022/06/02/formal.html https://brooker.co.za/blog/2022/06/02/formal.html
• cletus 4y ago
  None of these are top of my list. Mine is a better PHP. To be clear, I like PHP. It actually has many attributes that make it almost ideal as a Web development language, most notably: 1. Pretty much everything is request-scoped. This makes it a lot harder to leak resources when everything is torn down; 2. A stateless functional core. This avoids a lot of class loading that has dogged Java (as one example); 3. No ability to start threads. This is actually a positive. Most application code should avoid creating threads like the plague. But PHP comes with a lot historical cruft. It's type system is also primitive (Hack is a better example of this). Where I think this could really shine is in data analysis (ie the numpy/scipy realm).
  • cardanome 4y ago
    You might want to revisit PHP. It is getting better with every release. We have enums, match expressions, union types and much more now! As for the type system, haven't worked Hack but I absolutely love the gradual typing experience that PHP offers. Yeah, we had some things that could not be expressed but they are slowly being added, again we have finally union types! I would even say PHP might be the only mainstream language that offers a first class gradual typing experience. In Python your type hints are a lie as they are not enforced at all and different linter will give you different results and there is no standard. In JS, you have to use a whole other languages that compiles down to it, slowing you down with an extra compile step. Meanwhile PHP just works. Just use PHPstan for linting but even if you don't you get at least runtime checks.
    • onli 4y ago
      PHP might get better. But currently every new PHP release breaks compatibility with some things extensively used in old code bases. It's so much work! I wouldn't use it for new projects just because of that.
      • Cyberdog 4y ago
        PHP tends to be remarkably conservative in this regard. Things which are scheduled to be deprecated will typically just throw a warning for a major version or two before being removed entirely, and the migration documentation is very thorough for each major and point release. Yes, the older a code base is, the more of a pain it will be to migrate it to work with a major release without warnings, but that sort of technical debt will be the same regardless of language.
• jerf 4y ago
  The reactive programming language one is really interesting. A compiler ought to be able to compile "normal" straight-line code into conventional efficient code. It's hard to know how that sort of thing would "pollute" the rest of the code, though, like, will every program turn into a rat's nest of dependencies such that it's just impossible to manage or what? Hard to tell without trying, especially since developing such a language would also require significant effort into developing a standard library and best practices to go with it even if the language was in hand today. And one hell of a debugger. Circular dependencies are a problem, too; I'm inclined to ban them but that's probably beyond what a type system can help you with, or at least, any type system I currently know, so it's going to be an adventure. Still, there's a lot of things that would be more useful with such a language. In-memory highly-correct cache invalidation would become trivial code to write. In fact I think the cache would actually update itself live. Out-of-memory cache invalidation might be pretty easy. Certain auditing things would be easy. UIs would probably take some work to get right but would be interesting, at the very least. Game programming would also be interesting; a lot of game patterns would be incorporated into the language at that point. Probably need to be lazy; I suspect proactively recalculating everything all the time would be a bad idea. Haskell has pushed lazy programming a long way, but "re-thunkifying" a previously calculated cell would be a new frontier. Come to think of it, while I think the performance could be improved and you'd want to lift up to a full language eventually, I think a good Haskell programmer could bash together a prototype of this in a few days and start playing with it. It's going to need a lot of playing with before someone casts it into concrete as a language specification and corresponding compiler and runtime.
  • cmontella 4y ago
    I'm attempting to build such a language (you can find a link in my profile if you're interested. I don't want too much attention yet since I'm planning on a first release later in the year). You're right it can become difficult to follow code when it's not presented in a linear fashion. The flip side though is that you can write code in smaller chunks that can do a lot, so you write far fewer lines overall. The other thing is that it opens the door to more advanced tooling than we're used to as developers: things like time travel debugging, saving program state and querying it, or running hypothetical execution paths to find the best one. Bret Victor is famous for demoing prototypes of these debugging tools in one of his talks, and they are finally becoming real. My language turns out to be very fun to write UIs and games in, so I'm glad you honed in on those two examples. Actually one way to view it is that it's a programming language with a game engine as a runtime. But robotics is the primary application I'm targeting. In fact I had to choose between lazy and eager evaluation, and I've chosen eager because I want latency guarantees. With a lazy evaluation scheme, I was unsatisfied with the windup that would occur in some situations that would totally blow performance. And we don't have to recalculate everything all the time; we only have to recalculate the paths that have an input change. This may lead to recalculating everything, but most of the time we only have to focus on the execution path that is "dirtied" by the updated input. Anyway if you want to test drive such a language as you're imagining, send me an email and I'll give you a tour/demo. The language isn't really user-friendly yet so there are some pointy edges that make it unusable to new users at this time (which is the main reason I don't want more attention on it until that is resolved.)
• mazesc 4y ago
  Ada is already mentioned here. You also want to look at Dafny for a contract-based language: https://github.com/dafny-lang/dafny https://github.com/dafny-lang/dafny Since it has verification support it also covers the second point about semantic relations.
  • hwayne 4y ago
    Dafny is a really fun language and I've done some stuff in it before. I was really sad when MSR stopped working on it, but I think AWS has picked up the slack?
    • mazesc 4y ago
      Yes, it's under heavy development, and is getting various improvements for usability. You probably want to take a look at the release notes.
      • hwayne 4y ago
        glee
  • UncleEntity 4y ago
    I kind of thought Coco/R was a dead project but it seems dafny is using it as the parser generator library. …have to poke around a bit methinks.
• adenozine 4y ago
  Pyret has interesting contract functionality. Lua is based around tables, which, aren’t quite graphs but seem relatively close enough. What is a graph if not a collection of points associated with their edges? As far as semantic function relations, I could swear Ada has something like this, but it’s been more than a decade since I’ve touched any.
• geoffeg 4y ago
  I'd like to see more languages with built-in, language level support for unit tests. Pyret (https://www.pyret.org/ https://www.pyret.org/) does this but is considered a "learning language". I'm aware that to many people co-locating units tests with the functions they're testing is "bad" but I find it to be quite the opposite. The two are so tightly coupled that having the unit tests in a separate file, sometimes in a separate source tree, is counterintuitive to me.
  • weatherlight 4y ago
    Elixir has ExUnit which is apart of the language https://elixirschool.com/en/lessons/testing/basics https://elixirschool.com/en/lessons/testing/basics you can create comments above methods that act as tests
  • runevault 4y ago
    You can do this in Rust. Just put a namespace tagged as I think #[cfg(test)] or the like and they can live in the same file but won't be compiled into the non-test binary.
    • masklinn 4y ago
      Technically you don't even have to `cfg`-gate it, it's just good practice to avoid e.g. unused code warnings in the test module.
  • velcrovan 4y ago
    Racket has language-level support for contracts (https://docs.racket-lang.org/guide/contract-boundaries.html https://docs.racket-lang.org/guide/contract-boundaries.html) as well as unit tests (https://docs.racket-lang.org/rackunit/quick-start.html https://docs.racket-lang.org/rackunit/quick-start.html). It's true that Racket unit tests are an optional module within the standard library, but the command line tools and package system work directly with it. You can place unit tests right alongside the regular code but within a specially-named "test" submodule, so the unit test code doesn't run at runtime by default, except in certain contexts (package installation, "raco test" command, or running the file from within the Racket IDE).
• lkrubner 4y ago
  > A serious take on a contract-based language In Shen, the contract rules applied on each function are themselves a Turing complete language:: https://thestrangeloop.com/2014/shen-a-sufficiently-advanced-lisp.html https://thestrangeloop.com/2014/shen-a-sufficiently-advanced... https://shenlanguage.org https://shenlanguage.org "static type checking based on sequent calculus" "one of the most powerful systems for typing in functional programming"
  • nudpiedo 4y ago
    I had hopes in Shein but it was way too ambitious with way too less design (in the sense of UI/UX and art). Shein never became a serious language. It's highest point was when @deech made a talk about it and it also promoted their klambda but it had constant problems on every single aspect of the system and the design, from code size expanded as macros to unusable APIs due inconsistent design of libraries and features the author collected from everywhere. I even bought the book and felt deceived after it's unsuitability for anything other than academic examples on how to implement itself.
• zeckalpha 4y ago
  The closest examples I can thing of to these, in sequence: - Idris (dependent types rather than contracts, but squint and the UX is the same) - Python's decorators enable some of this, but Aspect oriented programming may also be what they are looking for. Boomerang is totally different but also an exploration in this space. - Io, or even JavaScript fit this description - there's a calculator like this I am forgetting the name of at the moment - this looks like Dependent typing to me, see Idris above
  • hwayne 4y ago
    Liquid Haskell is much closer to contracts than Idris, if you haven't heard of that already. I'm interesting in exploring contracts independently of types, though.
    • zeckalpha 4y ago
      I have, but Idris feels much more like a dynamically typed language. Just pretend they are saying contract when they say type.
• deleted 4y ago
  [deleted]
• alhirzel 4y ago
  Re the "everything is a graph" idea, Mathematica has been building primitives for some time toward this idea where literally everything is a graph: https://www.wolframphysics.org/ https://www.wolframphysics.org/
• Ericson2314 4y ago
  I'm sorry but these all seem superficial to me. E.g. contracts language could mean better understanding of substructural stuff so we can handle "real resources". But coming up with some syntax for this is the last step.
• d--b 4y ago
  The one I want to see is an analytics PL where dataframes are 1st class citizen. The only ones that do that right now are SQL. But really pandas shouldn't be a library in python, it should be in python itself with a specific syntax
  • kkwteh 4y ago
    What about R?
  • _dwt 4y ago
    That's R (and S/S+ before it), for better or worse.
  • deleted 4y ago
    [deleted]
  • _Wintermute 4y ago
    As it's been mentioned, that's pretty much R. Unfortunately if you need to do anything that can't be coerced into a dataframe it's quite ugly.
  • rak1507 4y ago
    Array languages (APL/J/K/Q) all do this well, particularly kdb
  • goatlover 4y ago
    Dataframes aren't first class in Julia? I guess it's provided by a library. But Julia has really good vector and matrix support with broadcasting, like R and unlike Python, which relies on NumPy for that (Pandas builds on top of NumPy). The R and Julia syntax are better than Python for vectorized operations, although NumPy and Pandas mostly make up for it using the magic methods. In terms of keystroke efficiency, nothing beats the array languages. One might think APL is a little too terse, whereas Pandas is a little on the verbose side.
• hota_mazi 4y ago
  I'd like to see a language with baked in support for dependency injections, so that my functions can take two types of parameters: its "real" parameters, which it needs to perform its function, and "dependencies", that are passed implicitly by the runtime. Basically, a formalization of Dagger/Guice into a language.
  • keybored 4y ago
    People have written drafts of a design for this for Rust. Calling it capabilities.
    • dymk 4y ago
      As a part of the language standard / standard library, or as a third party crate? I'm confused how this would work, as as far as I'm aware, making this a language-level feature would require significant changes to the ethos of the language. There are some examples, e.g. the Bevy ECS doing more or less dependency injection for you (and ensuring against things like aliased mutable references), which is pretty neat.
      • keybored 4y ago
        Part of the language https://tmandry.gitlab.io/blog/posts/2021-12-21-context-capabilities/ https://tmandry.gitlab.io/blog/posts/2021-12-21-context-capa...
        • dymk 4y ago
          Fascinating. Not sure what my opinion is of it yet. Reminds me of implicit parameters in Scala - https://docs.scala-lang.org/tour/implicit-parameters.html https://docs.scala-lang.org/tour/implicit-parameters.html Edit: I think I like it. It doesn't solve dependency injection like e.g. Guice but the examples given, e.g. providing implementations for traits defined in external crates that take arbitrary state, is compelling.
  • fabianhjr 4y ago
• abdellah123 4y ago
  > A language designed around having first-class GUI support That's Imba https://imba.io https://imba.io And it's fast, enjoyable and productive
  • zem 4y ago
    imba looks interesting, and promises full js interoperability, but i went through the docs and could not see anything about how that was done (specifically, using existing javascript libraries from imba).
• gonzo41 4y ago
  I'll keep my moaning about VB6 and JavaFX to myself. These days I think HTML5 and a decent theme is probably enough for everything. Yes it can sometimes suck, but there doesn't seem to be much love for heavy app development anymore.
  • nibbleshifter 4y ago
    > there doesn't seem to be much love for heavy app development anymore. I bet that changes eventually when we reinvent personal computing again (currently we are reinventing mainframes).
    • rileyphone 4y ago
      Hah, I like to think that we're finally wrapping up with mainframes redux, but someone has to make the next phase happen.
  • nudpiedo 4y ago
    You should try dart with flutter with ide support. Is not visual lang but it’s main purpose is totally that one.
• dfan 4y ago
  Inform 7 is the closest thing I can think of to "everything is a graph". Basically, objects in the world are vertices and relations are edges. When you first encounter relations they don't necessarily seem that exciting, but it turns out that having relationships between objects be a first-class concept really changes the way you think about and design systems.
  • hwayne 4y ago
    Did you know Inform is now (finally) open source?! https://github.com/ganelson/inform https://github.com/ganelson/inform
• shakna 4y ago
  > I also like the idea of modifying function definitions at runtime. I have these visions/nightmares of programs that take other programs as input and then let me run experiments on how the program behaves under certain changes to the source code. I want to write metaprograms dammit I've been working on an extremely dynamic programming language for a while. Ricing away on the syntax to make it as flexible as possible, whilst maintaining readability. One of the things that already works is some insane metaprogramming. It doesn't really have functions. It has callable lists of things. Which means you can modify them at runtime (still working on the names for the functions for doing that). It is stack-based, so it's a little quirky, but as a taste of some very simple meta-programming: block varname: add! 1 $ $varname : $varname end inc-env: a: 1 inc-env! a Bare-words are a symbol-type. So they only resolve from the environment when you ask for it with the $ instruction, which is how the above works. A little tedious, but does enable all kinds of dynamism.
  • funcDropShadow 4y ago
    Or you could just use a lisp. Someone had to say it.
    • masklinn 4y ago
      Or Smalltalk.
    • shakna 4y ago
      Well, now it's been said... Scheme is my all-time favourite language. The regularity of Scheme's syntax, and the way scoping works in the language, are certainly influential on the way I'm going about designing this weird thing.
      • nerdponx 4y ago
        Is Scheme scoping any different from any other language with lexical/static scoping?
        • 4y ago
• showerst 4y ago
  I'm a little surprised that nobody has pulled off the "VB6 of javascript". I don't mean one of the purely no-code products, but like a literal "create a new page, drag a button, then double click it to hop into the code for a new route and a new component and go straight into the onclick handler". Maybe that's harder than I can imagine, or it exists and just isn't a very good idea in practice (how would you even do responsive?) so it's not that popular. VB was a garbage language by modern standards but I always liked that they gave you a visual builder, but didn't try to hide the coding from you too much.
  • pddpro 4y ago
    VB6 was a gem. To a young me who was starting out programming, there was nothing more empowering than dragging a bunch of different buttons, resizing them with mouse, fiddling with their labels and creating a calculator within half an hour. I crave for a similar dev experience but no language today seem to possess that simplicity. Today, it's all container widgets of different kinds that I have no idea how to use.
    • agumonkey 4y ago
      I'd say it's probably on par with 2020s web. Web is more potent in theory but for a large amount of needs, VB+forms was actual RAD. If you need more complex then you dropped aside.
    • deergomoo 4y ago
      I wonder how much that is to do with the fact that software is expected to run on a much wider range of screen sizes these days? Doing a drag-and-drop sort of thing when you have to support phones up to big desktop displays tends to result in the container widgets you describe. On the web side I bet the right person could do something quite intuitive with CSS Grid though. You could drag out where you wanted various content blocks to appear at different screen sizes and generate a `grid-template-areas` [0] property to match it. [0]: https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-areas https://developer.mozilla.org/en-US/docs/Web/CSS/grid-templa...
    • ijidak 4y ago
• guelo 4y ago
  The reactive programming idea is implemented by the Kotlin Compose project as a compiler plugin so it behaves as a language feature. Compose is confusingly named in that there is a more popular Android UI toolkit with the same name built on top of the reactive feature. But Compose the compiler plugin is available by itself without the UI thing. I've been playing around with it and find it can really simplify a lot of code.
• keybored 4y ago
  Yes please to contracts. Dependent types and things like that are probably great. Being able to prove correctness is great. But I would settle for a way to declaratively express invariants and then let the language for the most part take care of inserting checks (in debug or using a special mode perhaps, or all the time) and generating tests/property tests. Why isn’t this more of a thing?
  • masklinn 4y ago
    > Why isn’t this more of a thing? Because that's a half-assed way of using and leveraging a good type system? DBC always strikes me as a "three blind men and a type system worth using" parable.
    • hwayne 4y ago
      Languages like Dafny and Ada show that you can contracts are great for augmenting a good type system by letting you express really complicated invariants that are tough to express in types. I didn't include them because they're not "mainstream", IMO.
    • keybored 4y ago
      To my mind contracts only complement a type system. I might want to effectively assert that a function returns a sorted list but I don’t want to assume it is true just based on the assertion never failing; I don’t want the sorted property to be reflected in the type. A type that proves that all values that inhabit it are sorted would also be nice. But if either the language doesn’t support dependent types or it is too difficult to prove then a contract could be used instead (again: not as a replacement). So to my mind (repeating idiom) it can work paralell to the type system. What’s not to like (honest question :))? It doesn’t have to be intrusive, as far as I can see.
      • anon291 4y ago
        > A type that proves that all values that inhabit it are sorted would also be nice. But if either the language doesn’t support dependent types or it is too difficult to prove then a contract could be used instead (again: not as a replacement). This is really easy in a dependently typed language. If something is hard to prove by construction you can do sort: List -> List which sorts a list without proving it to be sorted, and then write a function isSorted: List -> Maybe SortedList then just get your safe sort function safeSort: List -> SortedList safeSort l = case sort l of { Nothing -> panic; Just x -> x } Of course, you don't even need dependent typing to do this. If SortedList is a new nominal type and you trust your issorted function, everything works out.
• __alexs 4y ago
  I want a programming language that takes dynamic scope seriously. Not because I think it would be good, but I think it would be interesting.
  • Jtsummers 4y ago
    Like Common Lisp? You get dynamic scope through what it terms "special variables". They work as expected, and can be handy.
  • convolvatron 4y ago
    if I understand what you mean, elisp has dynamic scope. that's turned out to be useful to me a couple times...balanced against the hundreds of times that it did something I didn't want.
    • yakubin 4y ago
      You can opt into lexical scope for a script by starting it with: ;; -*- mode: Emacs-Lisp; lexical-binding: t; -*- You can then opt into dynamic scope for single variables, when it makes sense: (defvar variable)
  • masklinn 4y ago
    Lisps often have dynamic scoping. elisp used to only have dynamic scoping.
  • sparkie 4y ago
    Kernel is very interesting. It has fexpr-like combiners (operatives) which implicitly receive a reference to the dynamic environment of their caller. The environments are first-class and modelled as a DAG, with the local bindings in the root node with a list of other parent environments. The list of parents, and any bindings in the parent environments cannot be modified, but only the local bindings can. This puts constrains the operatives a bit - they can't just mutate anything in the dynamic environment, but only the local bindings of an environment for which they have a direct reference. Additionally, Kernel has dynamic binding built-in, and done in a nice way. You never explicitly access a dynamic variable but you only have an accessor function to it. A new scope is created when binding a dynamic variable, and the accessor will return whatever was bound anywhere in the dynamic extent of this scope. ($define! (with-str get-str) (make-keyed-dynamic-variable)) ($define! f ($lambda () (print (get-str)))) (with-str "Hello, world!" ($lambda () (f) (with-str "Goodbye, world!" f) (f))) Prints "Hello, world!" "Goodbye, world!" "Hello, world!" Perhaps the only downside to this is that a runtime error will be raised if `get-str` is called before a value is bound. I think it would be a bit nicer to include a default binding as an argument to the call of `make-keyed-dynamic-variable`. http://web.cs.wpi.edu/%7Ejshutt/kernel.html http://web.cs.wpi.edu/%7Ejshutt/kernel.html
• sebastianconcpt 4y ago
  For the really-dynamically typed language, that for sure is covered in Smalltalk. And for the first-class GUI support, in its own way too, but also Swift in XCode is very very good.
  • Cyberdog 4y ago
    Yes, Swift UI is awesome, if you don't fear making a UI in code as opposed to a drag-and-drop UI editor (the former always "clicked" better with me than the latter anyway, perhaps due to my web dev background). Really wish it had broader cross-platform support - but that's not exactly something VB was known for, either.
• 7thaccount 4y ago
  Interesting to see the complaints on J. I've been playing with the Q language (basically K with some sugar) that is part of KDB+ and I think it solves all your problems in that it is a lot cleaner/simpler, very fast, support for dictionaries, strings, JSON, datetimes (it is a database too), very terse file IO...etc. The only drawback is it's a commercial product. Who knows though. Maybe they would give you a pretty cheap license if you agree to use it mostly like a calculator (not for large-scale financial analysis). The whole install was basically a single executable and a license file. Very elegant. The doc is finally pretty good too. Edit: I tried using J and the install was pretty large iirc and the whole language is just too big and complicated. I know you can do cool stuff with it, but it just seemed to me that the cost was too high relative to benefit. Your mileage may vary.
• tasty_freeze 4y ago
  For reactive programming, verilog does that as its primary function. You can write imperative code as well. But it is a very primitive language that doesn't even support structures and loads of historical cruft. Systemverilog improves on it greatly. VHDL is contemporaneous with verilog and is much more principled because it was modeled on ADA. I have never heard of anyone using verilog for anything other than modeling logic.
• codesnik 4y ago
  All six features listed are very redundant or useless, in my opinion. Contracts? how they're different or less verbose than plain asserts? what they do better? "reactive programming"? if remove that strange code editing "replace", just a chain of definitions instead of variables in, say, ruby, gives you basically the same effect. etc. What I'd love to see is a language with a first class grammars to replace many uses of regexes or badly written DSL's, like what Perl6 tried to do. and, somewhat related (both are using backtracking), adoption of some of the ideas of https://en.wikipedia.org/wiki/Icon_(programming_language) https://en.wikipedia.org/wiki/Icon_(programming_language), not on a whole language level, but in some scoped generator context would be nice for some tasks I had to do.
  • choeger 4y ago
    Contracts, if done right, could be used by the compiler or some dedicated linter or tester before execution. This could open up safety guarantees that are way beyond what we can currently use. The question, of course, is what kind of constraint language is both useful and solvable. Unfortunately, people have been focused on the "dynamic" typing (i.e., no type checks) side of things for so long that static checking lags behind in usability (Rust is on a good way to improve things, though). Regarding first-class grammars you have to understand that it basically prohibits any other tool to parse your language. This means everyone has to fully implement the language to create any kind of small helper tool. In turn, your language might easily fall into the "exotic" camp (like, e.g., TeX - this language effectively has first-class grammars, albeit at a low level).
    • deleted 4y ago
      [deleted]
    • jillesvangurp 4y ago
      Kotlin has some functionality for this that help the compiler. A good example is the isNullOrBlank() extension function on String? (nullable String). It has a contract that treats the string as not null after it returns false. So if you do a null check, it smart casts to a non nullable string without generating a compile error. There are a few more variations of that in the Kotlin standard library and you can write your own contracts as well. There's just not a whole lot you can do with it other than stuff like this. But it's useful.
• PhineasRex 4y ago
  The dynamic typing example doesn't have anything to do with dynamic typing and is in fact already a feature of some statically-typed programming languages.
  • brabel 4y ago
    Common Lisp can do that: CL-USER> (defvar i 1) I CL-USER> (declaim (type (integer 1 10) i)) (I) CL-USER> i 1 CL-USER> (setf i 8) 8 CL-USER> i 8 CL-USER> (setf i (1+ i)) 9 CL-USER> (setf i (1+ i)) 10 CL-USER> (setf i (1+ i)) ; Evaluation aborted on #<TYPE-ERROR expected-type: (INTEGER 1 10) datum: 11>. CL-USER> i 10
  • em-bee 4y ago
    in pike: #pragma strict_types void main() { int(1..10) i = 3; i += 7; i += 1; write("%O\n", i); i = 11; } output: typetest.pike:6: Warning: An expression of type int cannot be assigned to a variable of type int(1..10). typetest.pike:8:Bad type in assignment. typetest.pike:8:Expected: int(1..10). typetest.pike:8:Got : int(11..11). Pike: Failed to compile script.
• krmboya 4y ago
  Imagine if the computing world would have standardized on Lisp and Smalltalk 40 years ago. If Alan Kay had got microprocessor companies to steal the Xerox microcode design like they got Apple to steal the GUI design, then the genius compiler engineers optimized the the heck out of it all. I can only shudder at what the supercomputer in my pocket would be capable of.
  • mirekrusin 4y ago
    We'd be all dead by now courtesy of GAI, at least with java and other abominations our generation is still fine ant'ing our way through feelin' happy fixing shit.
  • kaba0 4y ago
    I think the supercomputer in your pocket would be capable of the exact same things it can now, which are plenty cool as is. Lisps are not the God-languages.
    • notriddle 4y ago
      Also, the bottleneck that limits pocket computing is mostly HCI. It's really hard to design a good user interface for tiny screens and clumsy input devices. Lisp ain't gonna help with any of that.
  • timbit42 4y ago
    I'd suggest Scheme instead of Lisp.
  • mbrodersen 4y ago
    The computing world has never standarized on anything. And Lisp/Smalltalk aren’t the magic bullets you seems to think they are.
• abrax3141 4y ago
  “Everything is a graph” This is sort of an odd thing to want. You need a diversity of data structures. And BTW the acronym not withstanding, lisp represents graphs not lists.
  • SeanLuke 4y ago
    How so? The cons data structure only points to a single object. You could do singly-linked lists and trees (only with kids pointing to parent) and that's about it, right? And I guess simple loops?
    • abrax3141 4y ago
      The cons is a directed edge.
      • SeanLuke 4y ago
        To have a graph, in general, you have to have multiple directed edges from a given object. A cons does not offer this, and the best you could do would be to treat cons cells in a extremely convoluted way as binary hypergraph nodes. You said: "lisp represents graphs not lists". I think you meant that Lisp's defining data structure, based on the cons, was for general graphs, not lists. But that is not really true. If what you meant was "Lisp isn't just restricted to linked lists", sure, but that's true of every programming language with object arrays. So what?
        • abrax3141 4y ago
          Well, that's part of my point. However, in Lisp you get to macro the language into whatever you like, so you can make lisp into the desired graph language, layered on CONSs, but not so much with other languages because only in Lisp do you get to create an entirely new language. (People think of Lisp wrongly as a programming language, whereas it's really a meta-programming language.)
  • chickenpotpie 4y ago
    Under the hood, almost every data structure is a graph. Linked lists, trees, and heaps are all just graphs with certain requirements about their structure. Everything else can be represented as a graph, just not as elegantly. Also as a data point, I really really wish there was an everything is a graph language. I work in graphs all day (in the private industry) and I have to keep modeling them as arrays. It's a pain.
• Smaug123 4y ago
  Mathematica is a decent general-purpose language (though closed-source) and its "map the factorial function over the list" is exactly the same length as the quoted J code: #!&/@l It has the same "everything is a list" problem - it's really verbose at handling strings, for example, and last I checked its date-time handling was not only verbose but also [flat-out wrong](https://mathematica.stackexchange.com/q/239480/30771 https://mathematica.stackexchange.com/q/239480/30771). But it does support the dynamism mentioned immediately below, if you use `SetDelayed` (`:=`) rather than `Set` (`=`).
• amelius 4y ago
  Give me a language like Rust that allows me to define an efficient concurrent garbage collector as a library.
  • verdagon 4y ago
    You might be interested in Cone [0] which is centered around letting their users build custom memory management strategies, and then making them all work together with each other and a borrow checker. [0] https://cone.jondgoodwin.com/ https://cone.jondgoodwin.com/
    • amelius 4y ago
      Very interesting, thanks for the link!
  • lcall 4y ago
    As I noted elsewhere here, but since it is relevant to your comment I think: What I would like to see, along these lines, is a language that is as easy to learn/use as python/ruby/etc, but based on rust and rust-like, using rust libraries if at all possible, with garbage collection, so one can have an easy entrypoint to Rust, and if ever needing the full performance etc of rust, change a compiler switch (or something) and the full rust kicks in. In other words, a step-by-step learning process from simple to hard, maybe 2-4 levels, and you never have to throw away what you already learned and start over, when going to the next step.
    • Taikonerd 4y ago
      OCaml is "sort of like Rust, but with a GC." It could serve as a good introduction to functional programming, but without having to worry about the borrow checker. (I know that's not quite what you're saying -- it sounds like you're asking for a "Rust--", which is Rust with some complicated stuff turned off. But it's a start.)
      • lcall 4y ago
        Thanks. I think I read in wkp that Rust itself was originally written in OCaml. To slightly clarify my earlier comment: I am learning rust and plan to use it, but in the long run it seems it could save time for the world overall, if there were something to recommend to others, say, members of a team who want or need something easier, but is easily transitioned to full rust, with as much shared knowledge between the two as possible.
• okonomiyaki3000 4y ago
  Is there a language where everything is observable? Like RxJS all the way down. Can that exist?
• thetwentyone 4y ago
  The "reactive calculator" language the author wants is just Julia running in a Pluto notebook: https://github.com/fonsp/Pluto.jl https://github.com/fonsp/Pluto.jl
• ape4 4y ago
  I thought Pascal's ability to specify the bounds of an array were cool: vector = array [1..25] of real;
  • Bostonian 4y ago
    Fortran has that: real :: vector(-2:5) declares an 8-element array with bounds -2 and 5.
• api 4y ago
  I'd love to see a language with first class relational data types. This would basically be Turing-complete SQL with better syntax and obviously with a very modern language outside the relational stuff. Bonus points for providing hooks to allow transparent persistence of data, making the program and its database potentially the same thing and allowing easy persistent state programs with complex data. This could theoretically be added to other languages with libraries (with varying elegance depending on the language), but a real first class language would be carefully designed so that everything is serializable and deserializable with excellent performance. Things that fundamentally are state like network connections would also have to be carefully handled in some way where their essence was persisted such that the program could restore them and rebuild their state. This would pretty much give you an ORM without the impedance mismatch and would eliminate a TON of "CRUD" code and boilerplate.
  • mejutoco 4y ago
    I am thinking maybe Datalog? It seems to match all your features, including being available in other languages as a library. https://en.wikipedia.org/wiki/Datalog https://en.wikipedia.org/wiki/Datalog
  • cmontella 4y ago
    I helped build a language like this called Eve: https://github.com/witheve/Eve https://github.com/witheve/Eve It's defunct now, but it was indeed a Turing-complete SQL (but actually relational) with Prolog-like syntax and set semantics. We supported persisting data, and indeed you could think of it as programming within a database. Even though it's not worked on anymore, the last version in the repo worked pretty well IMO. I built a Spotify clone, and even a robot in the language. If you're interested in these ideas, you should give it a shot! Hopefully someone will pick up these ideas and run with them even further. It's a pretty mind-bending experience to program this way, and I promise you'll have a new perspective on programming as a practice once you grok it (that was common feedback from our users).
  • keybored 4y ago
    Cell?
• _gabe_ 4y ago
  > You know how annoying linked lists are? Graphs are 1000x worse. I thought linked lists were one of the easier data structures to implement? Is he saying they're annoying to use or implement here?
  • Georgelemental 4y ago
    > I thought linked lists were one of the easier data structures to implement? Unless you are a Rustacean…
    • deleted 4y ago
      [deleted]
• marcus_holmes 4y ago
  +1 for "I miss VB6" Using a dynamic web tooling product at the moment, and at first I was enthusiastic, but it's crippled compared to VB6
• bern4444 4y ago
  > A language with semantic relations This is a cool idea especially around a formal structure to express relationships between parts of your code. As to the example in the article on this, it seems property based testing is a decent way to achieve something like this with existing languages. A simple example of a property based test for a `const add = (a, b) => a + b` function would be that the result of the invocation is always larger than the arguments IE expect(add(a, b)).toBeGreaterThan(a); expect(add(a, b)).toBeGreaterThan(b); And then you can randomly generate or fuzz the values for a and b but the test should always pass
• vchuravy 4y ago
  > A better calculator language Especially with reactive programming as an ask there, I would recommend Julia with Pluto.jl (Pluto is a reactive notebook). > A really dynamically-typed language Julia ;) It is really dynamic, has meta-programming (macros + staged functions), solid semantics around eval/invokelatest that still allow for optimizations and you can add types at runtime (not modify them though).
  • rscho 4y ago
    Try APL for 6 months and tell me Julia is not too verbose for a calculator...
    • leephillips 4y ago
      Well, there’s always APL.jl.
• roflc0ptic 4y ago
  For the contract language, I’d recommend checking out Daml! It’s a Haskell-based smart contracts language with some pretty neat behaviors
• piggybox 4y ago
  I miss VB too. It's amazing how simple and intuitive it was comparing to how we create UIs nowadays.
• EdwardCoffin 4y ago
  With respect to the everything is a graph language, I think SetL [1] is pretty close. [1] https://en.wikipedia.org/wiki/SETL https://en.wikipedia.org/wiki/SETL
• kitd 4y ago
  I'd like to see a language that can clearly model concurrency using a Petri Net-like structure, ie a data flow language with flexible state/transition handling. Technically, the runtime is the easy part (relatively speaking). Modelling an array of swimlanes on a plain-text 2D page is the real challenge here IMO.
  • bmitc 4y ago
    Can you say more about this or have any particular references or applications? This seems interesting, and I'd like to know more. Is there any reason why this couldn't be a full 2D visual language, if done right?
    • kitd 4y ago
      Yes, it certainly could be (and probably has been) a visual language. And it could also be a plain text-based language too. But a visual language either requires specialist tooling which I think deters a large number of people, or if implemented in plain text, degenerates into ASCII art, which is very hard to manipulate in a simple text editor (believe me, I've tried!) A structured non-visual language is also possible, but that turns fairly quickly into a functional language which per se is not bad, but is not helpful when trying to present the overall flow of data around the network. You still have to jump around the file from function to function to try and understand what is going on. There must be a middle ground out there somewhere. Simple plain text presentation of multiple streams of processing.
      • bmitc 4y ago
        Thanks for the thoughts. Any particular references or applications of Petri nets? I found the book Petri Net Theory and the Modeling of Systems by James Peterson. I have either never heard of Petri nets or had but didn't pay attention.
        • ChadNauseam 4y ago
          Also check out https://statebox.org/ https://statebox.org/
• duped 4y ago
  > (Someone’s gonna tell me this is 100% smalltalk for sure) IIRC Objective-C can bind new methods at runtime
• julian_sark 4y ago
  As more of a Sys Admin / scripting type, I felt happy and sad at the same time at the actual mention of Visual Basic. VB is often scoffed at, and probably to an extend rightfully so. But those (i.e. VB1 through to VB6) were the ONLY languages that I ever managed to create useful, finished tools and programs in. Maybe it's part psychological, but I needed the approach where I created a neat UI first, got my methods pre-populated for me, and had something tangible to look at early in the process. Then went on to fill it with all with custom code. Yes, it's BASIC, but it was extensible. People I knew wrote OCX and such control elements, and code routines in DLLs in C/C++ and integrated that into VB projects, so the sky was still the limit. Staring at an empty text document with possibly some header file statements never evoked the same creativity with me that VB did. p.s. my proudest creation was a Windows 3.1 UI around the MS-DOS packing program "arj", for those who remember. Had I been a better businessman, that might have predated WinZip :)
  • Ken_At_EM 4y ago
    I don’t understand the the purely psychological disdain for Basic. I developed in an odd Language…LabVIEW…and I get what you’re talking about with first class GUI support and being able to see something each step along the way.
    • wolpoli 4y ago
      I recall most of the complaints had to do with the lack of inheritance and exception handling. On Error Resume Next anyone?
    • goto11 4y ago
      Some developers seem to react angrily towards anything which makes software development more accessible. That said - while VB had an amazing IDE and overall developer experience, the VB language itself had some serious warts.
      • Ken_At_EM 4y ago
        I could regale you with tales of the silliest conversation I’ve had with programmers who claimed that a graphical programming language couldn’t possibly do “real things” without even trying it. Your point is spot on. Wait until someone shows “real” programmers PLC ladder logic and they become aware of just how much critical infrastructure runs in a programming language that was literally designed to allow electricians and mechanical engineers automate real-time safety critical automation controls.
• funcDropShadow 4y ago
  This list of wanted language features is quite interesting. > A serious take on a contract-based language As the article itself notes Clojure does support contracts in the language and with libraries. But there has been a ton of research about that, e.g. JML [1]. > A language with semantic relations They can be expressed in contracts (e.g. Clojure) or with property-based test frameworks (e.g. Haskell, Clojure, and many others nowayday). > Everything is a Graph See graph rewriting, e.g. [2]. That was just my first google hit with the proper search term. > A better calculator language That idea looks to me like automatic transformation from offline to online algorithms [3]. I am not aware of any compilers being able to do that. But dataflow graphs can be used to design such systems. A list of such languages or libraries (e.g. for Clojure) can be found in this Stackoverflow article [4] > A really dynamically-typed language As some other answers here already mentioned modern static type systems are able to express, new types at runtime, e.g. with Scala's path dependent types. Again Clojure has an interesting entry here: clojure.spec [5], a runtime represented specification language, which can be used together with contracts or to formulate proeprty-based tests, or anything else you would like to do with it. Btw, I've only toyed with Clojure so far and I used to be an avid proponent of Haskell/ML-style static type systems. [1]: https://www.cs.ucf.edu/~leavens/JML/index.shtml https://www.cs.ucf.edu/~leavens/JML/index.shtml [2]: https://link.springer.com/chapter/10.1007/978-3-642-32211-2_12 https://link.springer.com/chapter/10.1007/978-3-642-32211-2_... [3]: https://en.wikipedia.org/wiki/Online_algorithm https://en.wikipedia.org/wiki/Online_algorithm [4]: https://stackoverflow.com/questions/461796/dataflow-programming-languages https://stackoverflow.com/questions/461796/dataflow-programm... [5]: https://clojure.org/guides/spec https://clojure.org/guides/spec
• Razengan 4y ago
  I’d like to see a modern BASIC-like language with line numbers :)
  • buescher 4y ago
    And that weird hybrid of line editor and full screen editor that eight-bit micro BASIC typically had.
• deltaonenine 4y ago
  Basically the man wants two opposite things. He wants contracts which is basically dependent types. These rules live in types and already exists in agda, Idris and coq and has a range of tradeoffs. Essentially these languages can enforce static checks and "contracts" so powerful you don't need unit tests. These "contracts" cover more ground and are safer then tests. The tradeoff is you need a big brain and lots of time to write these things. Then he wants a language that is truly dynamic. Which is like the opposite.
  • Jtsummers 4y ago
    Importantly, he doesn't want these conflicting things in one language.
  • zaphar 4y ago
    Actually he wants 6 different things. Some of those six different things might live in the same language some of them wouldn't but wanting six different things is in no way problematic. Different tools/toys for different jobs/hobbies.
    • deltaonenine 4y ago
      No he wants two things. Those 6 different things have isomorphisms and can be reduced down to two things. Think of it like 1*2 && 2. Both expressions are isomorphic. Dependent types literally encompasses everything he wants.
      • zaphar 4y ago
        He doesn't want the building blocks though. I could build those 6 things in any number of languages. What he want's are languages that explore making them ergonomic at the language level. That's like saying everything is doable in assembly. Which I mean sure, but that doesn't mean we don't want more ergonomic abstractions of those things.
        • anon291 4y ago
• AtNightWeCode 4y ago
  What I really miss is a lang that can be used to write code efficiently on smartphones.
• kemiller 4y ago
  I'd like to see one like rust, but with an AI-enabled compiler that can help you by suggesting implementations, and also estimating time/space complexity for you, detecting infinite loops, etc. So rust + copilot, but more, and designed into the language from the start, not cobbled together from public repos.
• patrec 4y ago
  > and basically no languages have an implication operator Prolog does, but more intriguingly, so does Nix!
  • ectopod 4y ago
    Also Visual Basic!
    • mirekrusin 4y ago
      And coq.
    • int_19h 4y ago
      Most PC BASIC dialects had the IMP operator - it was already there in GWBASIC, for example. But it's not quite the same thing, because all "boolean" operators in BASICs of old were actually bitwise! It worked in practice because the convention was to represent true as all-bits-set (i.e. -1 in two's complement). No short-circuit evaluation, of course - but back then, even languages that had dedicated boolean data types, like Pascal, didn't do it either.
  • hcs 4y ago
    I was surprised to find that Algol 60 had implication in among the Boolean operators, makes sense given the formal background, never got picked up by its many descendants.
• yewenjie 4y ago
  Recently I have been shopping for a configuration language that has static types and is easy-to-use and exports to common formats. Dhall came close but I was surprised to find that it does not support recursive types in a simple way. Maybe I should just use Haskell.
  • ghostwriter 4y ago
    what kind of software configurations may require recursive types? I've never had to encode trees in my configs so far.
• nudpiedo 4y ago
  well since all graphs can be represented as binary graphs and bgs can be conmfortably represented in lists, Lisp is de facto the friendliest graph language. But I agree with the sentiment, specially in regards the syntax... something new has to be imagined in order to representa language oriented toward graph traverse and manipulation.
  • vinodkd 4y ago
    I'm a little late to the party, but humbly submit my thoughts/design from a while back for your review/feedback: https://github.com/vinodkd/halo/blob/master/doc/UserGuide.md#basic-data https://github.com/vinodkd/halo/blob/master/doc/UserGuide.md... Edit: I've posted this same comment in multiple places in this conversation to get feedback from specific commenters, not as spam (it's a old personal project)
• carapace 4y ago
  Joy (implemented in Prolog) could tick some of these boxes. > window2 is an optimized version of window1 and should have the same outputs for every input. I should be able to encode that in the language, and have the tooling generate checks showing the two are the same, and also run benchmarks testing if the optimized version actually is faster. That should be possible with Joy, it's certainly something I want to explore. The interesting semantic relationships are those that let the machine automatically deduce optimizations > I also like the idea of modifying function definitions at runtime. I have these visions/nightmares of programs that take other programs as input and then let me run experiments on how the program behaves under certain changes to the source code. I want to write metaprograms dammit Lotta metaprogramming in Joy. Many functions work by building new functions and running them, it's a natural idiom in Joy. - - - - > A language designed around having first-class GUI support Red? ( https://www.red-lang.org/ https://www.red-lang.org/ ) > Visual Interface Dialect ... is a dialect of Red, providing the simplest possible way to specify graphic components with their properties, layouts and even event handlers. VID code is compiled at runtime to a tree of faces suitable for displaying. https://github.com/red/docs/blob/master/en/gui.adoc https://github.com/red/docs/blob/master/en/gui.adoc > You can’t work with strings, json, sets, or hash maps very well, date manipulation is terrible, you can barely do combinatorics problems, etc etc etc. I want a language that’s terse for everything. That also sounds like Red.
• TOGoS 4y ago
  As far as graph-based languages and languages with arbitrary metadata and relationships between objects are concerned, I've been mulling over a language where expressions are represented as RDF graphs and that has built-in support for manipulating RDF graphs. I've use the concepts as an intermediate representation for [mostly numeric] functional expressions in a few different systems (including Factorio's map generator), but haven't yet had the motivation to really flesh it out into a full-blown language. https://github.com/TOGoS/TOGVM-Spec https://github.com/TOGoS/TOGVM-Spec
• ceedan 4y ago
  > A language designed around having first-class GUI support Definitely qt, right? https://www.qt.io/ https://www.qt.io/ And HTML/CSS :downtrodden-developer-with-woozy-face:
  • dvirsky 4y ago
    Qt is not a language though?
    • anon291 4y ago
      Qt Quick is its own language (and a really nice one at that)
• hetzenmat 4y ago
  >> Everything is a Graph >> Lisp: everything’s a list Actually, the universal 'cons' cell data type of LISP (which is used to build lists) allows to represent graphs. Take, for example, Common Lisp. There are read-macros which make this possible: The expression #1=(hello . #1#) builds a circular list that only contains the symbol "hello" [1]. This example can be extended to build graphs. [1]: https://letoverlambda.com/index.cl/guest/chap3.html#sec_5 https://letoverlambda.com/index.cl/guest/chap3.html#sec_5
• joshlemer 4y ago
  Regarding graphs, I also have wondered why thy are not part of the regular suite of collections / literal syntaxes in most languages. In fact, they are really rare to even see in day to day programming, despite that most of our problems could make use of them in some way. I think part of it must come down to that you can't come up with a satisfactory way to encode graphs of data in a text-based literal. You will have to have a lot of repeating of nodes depending on how you want to express it. Take this simple graph from Wikipedia for instance https://upload.wikimedia.org/wikipedia/commons/thumb/5/5b/6n-graf.svg/1920px-6n-graf.svg.png https://upload.wikimedia.org/wikipedia/commons/thumb/5/5b/6n... We could express this as an adjacency list like Graph{ 1 <-> 2 1 <-> 5 2 <-> 3 2 <-> 5 3 <-> 4 4 <-> 5 4 <-> 6 } So there's already a lot of repetition of the node labels, but in real life applications you would probably have actual data associated with each node (like maybe a user_id, or a name, etc, whatever the "elements" of your graph are). Actually, you would in most cases have some key that identifies the node (like user_id), and some other data associated with the node (like date of birth, locale, etc). So the above notation would force some kind of notation like: ("user1", (1970, USA)) <-> ("user2", (1980, UK)) ("user1", (1970, USA)) <-> ("user5", (1990, RU)) ... So now the notation would require not only repetition of the node name, but also the data itself. This would be even more of a problem if the data was not a literal but was computed, like: ("user2", (getDateOfBirth("user2"), getLocale("user2")) So then the way around this would be to use the programming language's own variable/identifier system, like var user1 = ("user1", (1970, USA)) var user2 = ("user2", (1980, UK)) var user5 = ("user5", (1990, RU)) Graph{ user1 <-> user2, user1 <-> user5, ... } or perhaps some other node registration system, and then just repeat the labels Graph{ Nodes { ("user1", (1970, USA)), ("user2", (1980, UK)), ("user5", (1990, RU)), ... } Edges { "user1" <-> "user2", "user1" <-> "user5", ... } } So now we've avoided repeating data, but we still have to repeat nodes. In some situations, a different way of expressing a graph would also be preferable to adjacency lists (you might want an adjacency table, but in sparse graphs the list is more efficient) but by the way, for your graph system to be generally useful, you'll have to come up with a syntax and flexibility of design that ergonomically allows graphs that vary in: directedness: support for undirected and directed edges edge wights and data: edges could be identical or they could have weights or even keys and other attributes associated with them graph/multigraph: can there be multiple edges between the same 2 nodes? in statically typed languages, the data type of the "key" of the nodes, the "value" of the nodes, the "key", "value" of the edges, all have to be represented to some degree in the language's type system, so at least 4 generic parameters in a graph So, seems that there is just a huge design space and a variety of different usecases that makes coming up with a simple solution to the general problem very difficult.
• OneWingedShark 4y ago
  The items "A serious take on a contract-based language" & "A language with semantic relations" are covered pretty nicely by Ada's SPARK subset/tools... and the really great thing is that the "aspects" are part of the code and don't "go stale" like annotated comments do.
• travisgriggs 4y ago
  Elixir function marching feels kind of like contracts. You specify different variants of the same function for different contracts of what the inputs thrown at it are. I found that for much of my code it really separated the “where to next” from the “what to do”. And I became acutely aware of how many of the statements in other languages are more about “where does the code go next” and less about getting stuff down.
  • travisgriggs 4y ago
    marching = matching
• aidenn0 4y ago
  As TFA mentions, Smalltalk probably does it as well, but Common Lisp has all of the features for "A really dynamically typed language"
• danaugrs 4y ago
  Nice article! I'm building a language (https://flame.run/ https://flame.run/) in Rust that aims to have WebGPU+GUI support built-in. I'm playing with refinement types, which you effectively described in the second-to-last section. I'm not familiar with contract-based languages (other than Solidity), but I think refinement types would allow specifying function parameter requirements in a similar fashion to what you described in your contract-based language section.
• linkdd 4y ago
  For a contract based language and a "really dynamically typed language", I'm working on https://letlang.dev https://letlang.dev And it's because I haven't thought yet about how to do static type checking with such a feature. I haven't got any time to work on it in the past few weeks, and I'm the only dev (would really love some help). So, it will be ready when it will be ready :P
• chubot 4y ago
  Graphs are really common data structures but there hasn’t yet been an “everything’s a graph” language Nearly all common languages like Python, JS, Java, OCaml, etc. let you express graphs with records / objects. Everything is a graph! If you want a homogeneous graph, you just declare a single node type, like class Node: edges: List[Node] # or maybe Dict[str, Node] if you want them to be named payload: int - Or you can have a heterogeneous graph with many different node types. - If you want to label the edges, you can reify them as their own type The whole heap is graph-shaped! It's true that many programs in these languages are more tree-like than graph-like. And sometimes imperative code to manipulate graphs is hard to visualize. But I think there doesn’t need to be a separate language of graphs for this reason. --- If you want to see graphs done in plain C, look at this DFA code by Russ Cox: https://swtch.com/~rsc/regexp/regexp1.html https://swtch.com/~rsc/regexp/regexp1.html e.g. Implementation: Compiling to NFA (copy of lobste.rs comment)
  • chickenpotpie 4y ago
    Everything is a graph doesn't mean you can make a graph from other data structures, it means you have to make other data structures from a graph. A graph isn't defined as a list of nodes. A list is defined as a directed graph where each node has one vertex in each direction.
    • chubot 4y ago
      But why? What would that make easier? A list is defined as a directed graph where each node has one vertex in each direction. That definition works equally well for existing languages, e.g. struct Node { struct Node *prev, *next; int payload; }: The types gives you some constraints on the shape of the graph.
• notdan 4y ago
  Is there a good programming language and environment for kids? I started learning coding in my own around 10 yrs old with qbasic. Scratch is super aawesome, but what is the next level up from that that is actually typing the code out instead of moving puzzle pieces?
  • ianbicking 4y ago
    Microsoft MakeCode will feel very familiar coming from Scratch, but compiles into pretty readable (and editable) JavaScript, so it might be a good way to move up: https://arcade.makecode.com/ https://arcade.makecode.com/ And it still gives you the image editing tools (pixel editing for MakeCode), asset management, game loop, etc – all of which are too much to take on for a new programmer, but are really helpful, and hopefully make it feel like less of a regression.
  • timbit42 4y ago
    Logo? Racket?
• slaymaker1907 4y ago
  Depending on if you count it as a serious programming language, Racket has pretty much all the contract stuff. It has dedicated syntax for contracts, tight integration with the module system, and contract-random-generate attempts to generate a value satisfying a contract so writing an auto fuzzer wouldn't be too hard. In fact, I think Racket's system predates Clojure since there was the 2002 paper "Contracts for Higher-Order Functions" discussing it and Clojure first appeared in 2007. The only reason I would ever use Clojure instead of Racket would be if I needed to work with the JVM ecosystem or the browser via Clojurescript (which are compelling reasons). Totally agree about a good calculator language.
  • Scarbutt 4y ago
    Clojure mentions Racket's contracts as prior art: https://clojure.org/about/spec https://clojure.org/about/spec
• howling 4y ago
  His python code can be shorten to from math import * prod(map(factorial, l)) which isn't much longer than his J code especially if you count the number of tokens rather than the number of characters as the J code uses ridiculously terse names.
  • rak1507 4y ago
    You don't type tokens. Maybe if your keyboard has a 'factorial' button that's better, but mine doesn't. (Also J is extremely useful in a variety of other ways that would be much more complicated to replicate in python)
• rowanG077 4y ago
  Aren't contracts just a worse form of dependent types?
  • deleted 4y ago
    [deleted]
• Banana699 4y ago
  >A really dynamically-typed language Raku, previously known as Perl6, has this[1]. sub MAIN(Int $a, Int $b where 10 < $a < $b > 20) { say "OK: $a $b"; } You can also pull out the "Where" clause to ouside the function and make it define a new type. Raku is a very awesome language in general, for more reasons than one. [1] https://andrewshitov.com/2020/08/14/the-pearls-of-raku-issue-5-the-where-clause/ https://andrewshitov.com/2020/08/14/the-pearls-of-raku-issue...
  • bjourne 4y ago
    But does it generalize? $a > 10 is easy but what if you want "where $a and $b are coprime"? Or a subtype of the integers of all prime numbers.
    • Banana699 4y ago
      Yes, "$a > 10" isn't special, any boolean expression in its place is perfectly legal. Define coprime(Int a,Int b) -> Bool and request that coprime($a,$b) holds in the Where clause, define prime(Int a) -> Bool and request it holds for both $a, $b. The same machinery that runs "<" or ">" at runtime would just as well run coprime and prime.
• lcall 4y ago
  What I would like to see is a language that as easy to learn & use as python/ruby/etc, but based on rust and rust-like, using rust libraries if at all possible, with garbage collection, so one can have an easy entrypoint for anyone who wants that, and if ever needing the full performance etc of Rust, change a compiler switch (or something) and the full Rust kicks in. In other words, a step-by-step developer growth process from simple to hard, maybe 2-4 levels, and you never have to throw away what you already learned and start over, when going to the next step.
  • WalterBright 4y ago
    In D you can do everything with automatic memory management (garbage collection) if you like. It does make for quick development. You can also do explicit memory management, which of course takes more programmer effort. It turns out most programs wind up using a mix of the two, as GC is better for some things, and explicit is better for others.
    • lcall 4y ago
      Thanks, that is interesting. I mentioned Rust because of its broader use and apparent growth trajectory. Ie, to have the likeliest most uses in the most places, with minimal re-learning of a new language to work on a new codebase. Or to increase the odds when possible, at least (scripting but also Linux kernel use, etc). I will keep D more in mind though...is it on openbsd? (Edit: I see it is probably at least there via gcc, at least.)
      • mhh__ 4y ago
        D support for OpenBSD via GCC and dmd should be ok. Brian Callahan is a name to look for in the blogosphere. Also the D in gcc is full fat D, no "at least" required.
  • lcall 4y ago
    ps: to clarify: I am learning rust, but in the long run it seems it could save time for the world overall, if there were something to recommend to others, say, members of a team who want or need something easier, but is easily transitioned to full rust.
• WalterBright 4y ago
  D has contracts built in. https://dlang.org/spec/function#contracts https://dlang.org/spec/function#contracts
• wheelerof4te 4y ago
  For a GUI-focused languages, we have C# and Java. For a fully dynamic scripting language, look no further than Python. Function inheritance? We have decorators in Python already, and most functional languages support seamless function composition. Take your pick between Haskell, Lisp, Scala and even Rust. Designing a new languages needs to have a pragmatic purpose and sometimes, valid ideology.
• yencabulator 4y ago
  For contract-based programming, I'm personally planning on experimenting with Prusti: https://github.com/viperproject/prusti-dev https://github.com/viperproject/prusti-dev The withdraw example would look something like impl Account { #[requires(amount <= self.balance)] #[ensures(self.balance >= 0)] pub fn withdraw(&mut self, amount: uint) { ... } } and Prusti has a good story for going from this to larger proofs.
• bjourne 4y ago
  I want a language for safe collaboration. Suppose I create a GPL-licensed library for decoding mpeg4 that I publish somewhere. Someone should be able to fix a bug in that library and publish a new with minimal involvement from my side and minimal overhead work. I shouldn't have to review pull requests or anything. It should all be automatic and the language should protect against malicious users inserting flawed code. Copyright would be handled using a block chain so every commit's author would be publicly visible to users of the library. The "source code" would be stored as a call-flow graph and perhaps nodes would have different permissions to sandbox the effect of untrusted contributors changes.
  • OneWingedShark 4y ago
    Honestly, Ada fits a LOT of that bill. The type-system and forced spec/implementation split both work well to catch errors; you can go further with SPARK [proving] and using Pre- and Post-conditions, type-invariants.
  • mynameismon 4y ago
    > Copyright would be handled using a block chain so every commit's author would be publicly visible to users of the library. I think you might not want a blockchain: what you need is a merkle tree, which is basically what backs both git and blockchain
• andrewshadura 4y ago
  A language designed around having first-class GUI support: Tk dialect of Tcl
• di4na 4y ago
  I want an IaC and nixos level language with prolog inspiration. Let me express how to go from fact to goals with constraints. It would probably make more sense than HCL or Pulumi. Agents based language are close in theory but they are really targeted at specific simulation and not at explaining what went wrong. It would also make it easier to do partial application and resumption of it. And probably make constraints for security easier. Probably make composition of infra level work easier too.
  • sourceless 4y ago
    I've been working on something like this (though written using CLojure & core.logic)! I'm glad to see there's someone else out there who think's it's useful.
• thom 4y ago
  I would love to see a programming language with some sort of bitemporal data store built in. Let me define dataflow graphs, including highly stateful logic over streams of data, but let me go back and change data, or fix bugs and replay from the beginning of time and view the state of the system (in a nice REPL) at any point in time. Gimme a fast, distributed runtime that can scale to any level of complexity or data size. I can imagine it being Materialize who build this first but in my heart of hearts I’d love it not to be SQL.
• tobyhinloopen 4y ago
  What’s the point of contracts? Can’t you use tests for that?
  • Jtsummers 4y ago
    Think of them as richer versions of asserts. And in languages where they are first-class parts of the language, that is they become meaningful metadata on functions, variables, classes, etc., then you can end up deriving tests from them or running them through a prover (not always possible, or might restrict you to a subset of the language). They are complementary to the type system and test systems, just like asserts are, but richer in potential than plain asserts. See the recent AdaCore blog post: https://blog.adacore.com/i-cant-believe-that-i-can-prove-that-it-can-sort https://blog.adacore.com/i-cant-believe-that-i-can-prove-tha... HN discussion: https://news.ycombinator.com/item?id=31975507 https://news.ycombinator.com/item?id=31975507
• km3r 4y ago
  We use an internal language at work thats a graph based language with first party GUI support. Some interesting info about it: * There is just a few primitive node types (Class, Method, Attribute, Relationship, GUI Bucket) with the rest of the system being derived off of that. * Underneath is a replaceable layer of java (+js/html for UI). * Still not sure if it's quite front or back end code, as it contains business logic, GUI info, and largely runs on the server. * Back end improvements happen automatically and system wide. The limiting nature of the graph ensures minimal regressions. * Most of the SKU product code is contained within this graph, making for definable relationships between any part of the code. * Internal languages mean lots of internal tools that enable better management of the graph.
• quickthrower2 4y ago
  “A serious take on a contract-based language“ Not ambitious enough. We already have dependent type systems and what I will call “property based types” since I forget the proper name e.g. https://ucsd-progsys.github.io/liquidhaskell-blog/ https://ucsd-progsys.github.io/liquidhaskell-blog/. The compiler can check anything from silly out of bounds conditions to more complex assertions. Even without that, a good type system will allow you to alias types but have a constructor do a check. Once you use the Percentage0_100 type you know that it must be in that range, and the method doesn’t need to check it again. In think Haskell is “too much” for a lot of teams, but sprinkling in some compile time assertions and making that ergonomic with linting and so on would be a boon on par with async/await. “Unit test?” no need, I have a proof!
  • mbrodersen 4y ago
    Even better: Dependent Types combined with Refinement Types. See F* (F-star).
    • quickthrower2 4y ago
      Refinement Types… thats the phrase I was looking for. Thanks!
• frabjoused 4y ago
  I feel VB6 appeals to sys admin types who don't get kept up at night by misaligned padding or a misplaced pixel. It's similar to the MS Access crowd that happily pump out functional abominations without a second thought. My first UIs were made using AutoHotkey in the early 2000s and while I felt empowered, I ditched it as fast as I could.
• omginternets 4y ago
  Is there a relationship between contracts and proof languages like Idris, or are these completely different approaches?
• borissk 4y ago
  A guy I know actually did make a graph programming language, implemented on top of neo4j. It was very slow, but he did use it successfully for analyzing SQL stored procedures and finding fraudulent transactions.
• Lichtso 4y ago
  About "Everything is a Graph", I tried to design programming languages for graph processing a few year back. The problem here is the "language" part as language always implies sequence (because that is what text is). Sequences of statements just don't cut it. In order to efficiently work with graphs, you need to work in graphs. Thus, it becomes a program graph rather than a programming language. And at that point you run into issues of general tooling. Every single tool ever invented around programming is used in combination with text and sequences. In retrospective it is funny how everybody implicitly assumes that the next big thing will be yet another programming language. And I am not talking about no-code or AI code synthesis.
  • DonaldFisk 4y ago
    The point about Lisp is that, lists aren't just the main data structure: programs themselves are lists. Many years ago, I began developing a language in which programs are directed graphs (http://fmjlang.co.uk/fmj/FMJ.html http://fmjlang.co.uk/fmj/FMJ.html), and on which I still work when I find the time. One of my aims was to make the language fully homoiconic, like Lisp. The problem I had, and which I've only solved recently, is that directed graphs in mathematics just have vertices and arcs, each of which can be labelled, and that's all, but programs in FMJ have vertices (but with ordered inputs and ordered outputs) and arcs, but also constants and enclosures. So programs are extended directed graphs, and the extensions are only really useful for writing programs. Now I have shown that programs are homeomorphic to directed graphs in the mathematical sense - graphs with just labelled vertices and arcs can be converted to programs and vice-versa. I have also added graph processing primitives, but haven't got much further as I've been busy with other things. I do intend to update my web pages soon, with descriptions of the graph processing and the other features I've added.
    • nudpiedo 4y ago
      After the introduction regarding programs that should be different, etc I expected something innovative but... how is fmjlang different than any lisp? it seems like nothing else than visual polish notation with lisp semantics. Perhaps the "parallel" part is just a different evaluator for a lisp, but I see no other differences to be honest.
• 6510 4y ago
  I want to see an emulated hardware design lang to make desktop apps.
• icodestuff 4y ago
  There are plenty of really dynamically-typed languages. io is probably the most so of them, but I'd argue Smalltalk and even Objective-C are pretty up there.
• woojoo666 4y ago
  I'm curious what the author means by "everything is a graph". Are graphs the primitives of the language? How are graphs defined or specified by the programmer, without using an even lower level primitive? The author says: > Give me a language where key-value maps are emulated with directed bipartite graphs So this means you can't define graphs using key-value dictionaries (like Smalltalk or Javascript with their objects primitives). So how exactly are these graphs defined? RDF format? Something I've found while trying to design languages is that the hardest part is running into contradictions and circular logic. And I feel this "everything is a graph" idea will very quickly run into this issue.
  • hoosieree 4y ago
    Maybe the author implies APL-style programming: in APL, your base datatypes are "array of number" or "array of character" and there's first class support for multidimensional arrays and/or nested arrays. But the main thing is that all the operators take arrays as input and return arrays as output. With "everything is a graph", all your operators would expect to consume and produce graphs. So you'd have operators for parent/sibling relationships, operators for various kinds of traversals, extracting graph shape information to build higher-level operators like subgraph isomorphism (or maybe that would be a built-in operator).
    • woojoo666 4y ago
      So the idea is to first define some static graphs and then use operators to construct larger (possibly dynamic) graphs? But to define those small static graphs in the first place, you have to either use key-value mappings (how Smalltalk/Javascript does it) or maybe RDF format or something.
      • hoosieree 4y ago
        That is how I imagine it, yeah. If I was designing an "APL for graphs" I would probably take a lot of inspiration from NetworkX[1]. Especially: generators for various graph types, the ability to read dicts/lists as graph data, and a huge suite of graph-related functions. But I would also want dedicated notation for the most common/composable operations like APL. I particularly like how Jq[2] "functions" are inherently combinators, and Jq has some nice semantics for mapping and filtering operations on trees, but I don't really like its syntax that much. [1]: https://networkx.org/documentation/stable/tutorial.html https://networkx.org/documentation/stable/tutorial.html [2]: https://stedolan.github.io/jq/ https://stedolan.github.io/jq/
• anotherrandom 4y ago
  Java ecosystem but C# language. There needs to be a J# project lmao
• mbrodersen 4y ago
  > A serious take on a contract-based language This already exists: programming languages that supports refinement types. Examples are Liquid Haskell and F* (F-star).
• gwright 4y ago
  > A better calculator language See Calca: http://calca.io http://calca.io
• directionless 4y ago
  For calculator languages, I think there are several choices. Depends a bit on what you know, and what you need... Frink (https://frinklang.org/ https://frinklang.org/) has been around for ages, and is rooted in physical unit conversions Calca (http://calca.io/ http://calca.io/) has come up a handful of times. It looks pretty reasonable R, if that's your flavor Anything with a REPL. Though the OP suggests these are cumbersome, I'd counter argue that anything you know well is usually more efficient than learning something new. A very long list of commercial tools: Matlab, Mathematica, WolframAlpha, STS, SAS, etc
• patientplatypus 4y ago
• ParetoOptimal 4y ago
  > I want a language that’s terse for everything. Maybe you could namespace operators. Haskell and lenses is pretty nice here.
• mpjan 4y ago
  > A better calculator language https://calca.io/ https://calca.io/
• ivolimmen 4y ago
  > I miss VB6. Me too. But there is something nice on Linux called GAMBAS: http://gambas.sourceforge.net/en/main.html http://gambas.sourceforge.net/en/main.html
• NightMKoder 4y ago
  This is very nonambitious, but I’d love to see a Clojure with less LISP. That is - something like JS syntax but with immutable by default types and const only bindings. Macros would be great too, even if they require a different compilation mode. Top it off with great standard library that has _all_ the collection operations you’ll ever need (e.g. partition-all and dedupe in Clojure). nREPL support or the like is a hard requirement. Spending the last 6 years writing Clojure has been great. That said, the parens don’t add positively to the experience. They feel like semicolons in C - “the compiler is too dumb to understand this so I have to help it.”
  • nudpiedo 4y ago
    did you try structural editing and using keyboard shortcuts to select, cut and paste the whole inner contents of a parens scope? for my that made the whole difference and I never found such a similar good feel in other languages. Fair to mention dart (flutter) in VSCode has a refactoring option which removes, adds and modifies all widgets but it falls short in comparison to lisp.
    • NightMKoder 4y ago
      Structural editing is basically a hard requirement with Clojure - I don't think you can realistically live without it. Paredit is fine, but it does take 2-3 months for your fingers to adapt. It would be even better if they didn't have to though.
  • jhchabran 4y ago
    I'm wondering if that has to do with the time spent writing Clojure code? I have only wrote LISP code during uni and on pet projects and I always feel like the parentheses are making things easier to visually process. The AST is explicit and basically just before my eyes, and it looks nice because of the functional style.
  • ivank 4y ago
    Elixir feels similar, being built on macros and doing transformations on immutable values.
• abrudz 4y ago
  input = 1 out1: input + 1 #out1 is now 2 input = 4 #out1 is now 5 out2: out1.replace(+, -) #out2 is now 3 # let's pull an APL input = 4 2 #out1 is 5 3 #out2 is 3 1 Not quite as sleek syntax, but in APL with my Lazy library[1] input ← 1 ]lazy out1 ← input + 1 out1 2 input ← 4 out1 5 ⎕FX'out1' '\+'⎕R'out2' '-'⎕NR'out1' out2 3 input ← 4 2 out1 5 3 out2 3 1 [1] https://github.com/abrudz/Lazy https://github.com/abrudz/Lazy
• dan-robertson 4y ago
  It’s not exactly a language but the Emacs calculator (aka GNU Calc) can do a lot of the things J does for the author. Product of factorials would be: v M ! v R * Where the v may be capitalised if you like and the spaces are the way the commands are written but aren’t typed. That decomposes into some easy mnemonics: Vector Map factorial, Vector Reduce multiplication. It has a bunch of mathematical features, a quick interface for plotting simple graphs (with gnuplot), some symbolic algebra, and it sort-of has the reactive feature too. (I think there’s also a mode for using it in files). Date handling is ok but simple (a date/time is internally represented as a Julian day so if you add 1 to a date/time you get the next day; times go into the fractional part. Leap seconds / time zones aren’t handled. There is an option to configure when your calendar switched from Julian to Gregorian. It’s usually fast enough for what I use it for but it can be limited by performance.
• ksherlock 4y ago
  Some versions of K have reactive programming -- they call them views. normal assignment: var : expression view: var :: expression https://code.kx.com/q/learn/views/ https://code.kx.com/q/learn/views/ https://code.kx.com/q4m3/9_Queries_q-sql/#911-views https://code.kx.com/q4m3/9_Queries_q-sql/#911-views
• B1aZer 4y ago
  Solidity (ethereum cryptocurrency language) is based on contracts. Svelte (javascript framework) has reactivity build in.
• zelphirkalt 4y ago
  > The standard bearer for contracts used to be Eiffel, which people stopped caring about in the mid-90’s. Nowadays the only mainstream language to get serious about contracts is Clojure. Most languages have a contracts library, which mean the language doesn’t have affordances to use contracts well. Take the predicate is_sorted(l) Some languages though have contracts as a library, but that library uses tools of the language, to actually change the language. Languages with capable macro systems! Just because something is a library, that does not mean, that it will not integrate into the language, even beyond a library function level. In language with a capable macro system, one can create new keywords and forms, which are just as much part of the language, as predefined things. It allows to create ones "affordances". With all the interest in language features, I am surprised, that this was overlooked. The post inspired me to try myself at creating a macro in Scheme / GNU Guile, which implements the "requires" and "ensures" idea, although evaluating at runtime: https://notabug.org/ZelphirKaltstahl/guile-examples/src/d749de48307cebe279215ab5df50853c9d100b2f/macros/contract.scm https://notabug.org/ZelphirKaltstahl/guile-examples/src/d749...